String类

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实例。 类String中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。
特点： 字符串的值在创建后不能被更改。

示例：

  1. package moreclass;
  3. import java.lang.String;
  5. public class StringClass {
  6.     public static void main(String[] args) {
  7.         // 内存中只有一个"abc"对象被创建，同时被s1和s2共享。
  8.         String s1 = "asdf";
  9.         String s2 = "asdf";   
  11.         String s3 = "abc";
  12.         s1 +="ghj";              //字符串拼接
  13.         System.out.println(s1);
  14.     }
  15. }

String深层实现(字符数组)

  1. String w="lang";
  3. //等同于
  4. char data[]={'l','a','n','g'}'
  5. String w = new String(data);

String类的使用步骤

1、查看类：java.lang.Sting
2、查看构造方法：

  1. public String();        
  2. public String(char[]);
  3. public String(byte[]);

示例：

  1. public class StringClass {
  2.     public static void main(String[] args) {
  3.         String name_1 = new String();      //public String();
  5.         char data_1[]={'l','y','l'};
  6.         String name_2 = new String(data_1);        //public String(char[]);
  7.         System.out.println(name_2);
  9.         byte data_2[]= {54,55,56};
  10.         String name_3 = new String(data_2);        //public String(byte[]);
  11.         System.out.println(name_3);
  12.     }
  13. }

结果：
image.png

String类的常用方法：

  • indexOf() 返回指定字符得索引
  • charAt() 返回指定索引处得字符
  • repalce() 字符串替换
  • trim() 去除字符串两端的空白
  • split() 分割字符串 返回分割后的字符串数组
  • getBytes() 返回字符串的byte类型数组
  • length() 返回字符串的长度
  • toLowerCase() 字符串转小写
  • toUpperCase() 字符串转大写
  • substring() 截取字符串
  • equals() 字符串比较


使用示例：

  1. package array;
  2. import java.lang.String;
  3. import java.util.ArrayList;
  5. public class StringClass_1 {
  6.     public static void main(String[] args) {
  7.         String name="langyongling";
  8.         String name_1="langyonlin";
  9.         System.out.println(name.indexOf(1));
  10.         System.out.println(name.getBytes());
  11.         System.out.println(name.length());
  12.         System.out.println(name.equals(name_1));
  13.         }
  15.     }

static 关键字：

使用：可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属 于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

定义和使用格式
类变量：当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

类变量：使用 static关键字修饰的成员变量。
格式：

  1. static  数据类型  变量名;
  2. //like
  3. static  int number;

例题：
基础班新班开班，学员报到。现在想为每一位新来报到的同学编学号（sid），从第一名同学开始，sid为 1，以此类推。学号必须是唯一的，连续的，并且与班级的人数相符，这样以便知道，要分配给下一名新同学的学 号是多少。这样我们就需要一个变量，与单独的每一个学生对象无关，而是与整个班级同学数量有关。
代码示例：

  1. package moreclass;
  3. import java.lang.String;
  5. public class Student {
  6.         private String name;
  7.         private int age;
  8.         private int sid;   // 学生的id
  9.         public static int studentNumber = 0;  // 类变量，记录学生数量，分配学号
  11.         public Student(String name, int age){
  12.             this.name = name;
  13.             this.age = age;
  14.             this.sid = ++studentNumber;   // 通过 numberOfStudent 给学生分配学号
  15.         }
  17.         public void show () {
  18.             System.out.println("Student : name=" + name + ", age=" + age + ", sid=" + sid);   // 打印属性值
  19.         }
  20.     }
  23. --------------------------------------------------------------------------------------------
  24. //方法的调用
  25. package moreclass;
  27. import java.lang.String;
  29. public class StudentData {
  30.     public static void main(String[] args) {
  31.         Student stu1=new Student("小龙女",18);
  32.         Student stu2=new Student("杨过",44);
  33.         stu1.show();
  34.         stu2.show();
  35.     }
  36. }

静态方法

当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要 创建类的对象。调用方式非常简单。 类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。
定义格式：

  1. 修饰符 static 返回值类型 方法名 (参数列表){
  2. // 执行语句
  3. }

举例：

  1. public static int student(int age){
  2.     int c = age;
  3.     return c;
  4. }

在Student类中定义静态方法
静态方法调用的注意事项：
1、静态方法可以直接访问类变量和静态方法。
2、静态方法不能直接访问普通成员变量或成员方法。
3、成员方法可以直接访问类变量或静态方法。
4、静态方法中，不能使用this关键字。

调用格式

被static修饰的成员可以并且建议通过类名直接访问。
格式：

  1. // 访问类变量
  2. 类名.类变量名;
  4. // 调用静态方法
  5. 类名.静态方法名(参数);

示例：

  1. public class StuDemo2 {
  2. public static void main(String[] args) {
  3. // 访问类变量
  4. System.out.println(Student.numberOfStudent);
  5. // 调用静态方法
  6. Student.showNum();
  7. }
  8. }

静态代码块

静态代码块：定义在成员位置，使用static修饰的代码块{ }。
位置：类中方法外。
执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
作用：给类变量进行初始化赋值

格式： 

  1. public class ClassName{
  2. static {
  3. // 执行语句
  4. }
  5. }

示例：

  1. public class Name {
  2.     public static int number;
  3.     public static ArrayList<String> list;
  5.     static {
  6. // 给类变量赋值
  7.         number = 2;
  8.         list = new ArrayList<String>();
  9. // 添加元素到集合中
  10.         list.add("张三");
  11.         list.add("李四");
  12.         System.out.println(list);
  13.     }
  14. }

目的：

static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况 下，去调用方法。

Arrays类（java.util.Arrays）

概述：Arrays类包含用来操作数组的多种方法，排序或者搜索等。其所有方法都为静态方法，调用简单。

操作数组的方法：将数组转化为字符串输出

  1. public static String tostring(int[] a )   //返回指定数组内容的字符串表示形式

示例：

  1. package moreclass;
  2. import  java.lang.String;
  3. import java.util.Arrays;
  5. public class ArraysClass {
  6.     public static void main(String[] args) {
  7.         int[]  arr={1,2,3,4,5,};
  8.         String s= Arrays.toString(arr);   //将数组arr转换为字符串
  9.         System.out.println(s);
  10.     }
  11. }

结果：
image.png

对数组里的数字进行升序排序：

格式：

  1. public static void sort(int[] a)        //对数组内容进行升序排序用到的方法
  1.  public static void main(String[] args) { 
  2.      // 定义int 数组 
  3.      int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
  4.      System.out.println("排序前:"+ Arrays.toString(arr));            // 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6, 2] 
  5.      // 升序排序 
  6.      Arrays.sort(arr); 
  7.      System.out.println("排序后:"+ Arrays.toString(arr));            // 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46, 48] }

将一个随机字符串中的所有字符升序排列

  1. package moreclass;
  2. import  java.lang.String;
  3. import java.util.Arrays;
  5. public class ArrayTest {
  6.     public static void main(String[] args) {
  7.     // 定义随机的字符串
  8.     String line = "ysKUreaytWTRHsgFdSAoidq";
  9.     // 转换为字符数组
  10.     char[] chars = line.toCharArray();
  11.     // 升序排序
  12.     Arrays.sort(chars);
  13.     System.out.println(chars);
  15.     }
  16. }

结果：
image.png


Math类：

示例：

  1. package moreclass;
  3. import java.lang.Math;    //Math类包含基本数学运算的方法，其所有方法都为静态方法，且不会创建对象
  5. public class MathTest {
  6.     public static void main(String[] args) {
  7.         System.out.println(absolute());
  8.         System.out.println(floor());
  10.         MathTest mt = new MathTest();
  11.         mt.ceil(-3.44);
  13.     }
  15.     public static double absolute() {   //绝对值
  16.         double a = Math.abs(-3.44);
  17.         return a;
  18.     }
  20.     public static double floor() {   //返回小于等于参数最大的整数
  21.         double f = Math.floor(5.88);
  22.         return f;
  23.     }
  25.     public void ceil(double c) {   //返回大于等于参数最小的整数
  26.         System.out.println(c);
  27.     }
  28. }

练习

计算在-5.8到11.1之间，绝对值大于5或者小于2.6的整数有多少

  1. package moreclass;
  3. import java.lang.Math;
  4. import java.util.ArrayList;
  6. //-5.8到11.1之间，绝对值大于5或者小于2.6的整数
  8. public class MathTest {
  9.     public static void main(String[] args) {
  10.        double max=11.1;
  11.        double  min=-5.8;
  12.        int acct=0;
  13.         for (double i = Math.ceil(min); i <Math.floor(max) ; i++) {
  14.           if(Math.abs(i)>5 || Math.abs(i)<2.6){
  15.               acct ++;
  16.           }
  17.         }
  18.         System.out.println(acct);
  19.         ArrayList<String> list = new ArrayList();
  20.     }
  21. }