JAVA12-Scanner类、Random类、ArrayList类、String类、static、Arrays类、Math类、静态方法

1.类 Scanner

1.1.引用类型的使用步骤

（1）导包： import 包路径.类名称；// 导包语句在package语句之后，public之前写。

此前我们学习到如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。现在更正一点：只有java.lang包下的内容，不需要导包即可使用，如String就是java.lang下。

（2）创建对象

类名称对象名 = new 类名称（）；如果它需要构造方法的参数，那括号类需要写参数；

（3）使用对象

对象名.成员方法名（）；如果需要传参，我们在括号内加参；

当我们在api文档中找到对应的api类，主要看三点内容：包路径、构造方法、方法

1.2.Scanner类

通过Scanner类构造方法得知，Scanner类构造方法均含参，其中 system.in

比方说获取键盘输入的一个数字，其中返回的值中看到有int，其中int radix是进制，暂时不用

其中：String字符串比较特殊，不是nextString（）；没有这个方法

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Scanner;
  3 public class Demo05Scanner01 {
  4     public static void main(String[] args) {
  5         Scanner sc = new Scanner(System.in);// 创建对象
  6         int s = sc.nextInt();//获取键盘输入的一个int数字
  7         String str = sc.next();// String字符串比较特殊，不是nextString（）；没有这个方法
  8         System.out.println("输入的int数字是"+s);
  9         System.out.println("输入的字符串是"+str);
 10     }
 11 }

实际上我们键盘录入的都是字符串，只是nextInt将字符串转化为int类型数字。

练习：键盘输入两个数字，求和

分析：既然是键盘输入，则用到Scanner

Scanner三步骤：导包、创建、使用方法

既然是三个数字，类型一致，则不需要创建三次对象，调用三次nextInt（）方法即可

无法同时判断三个数字谁最大，第一步判断前面两个，再和第三个比较

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Scanner;
  3 public class Demo05Scanner02Sum {
  4     public static void main(String[] args) {
  5         Scanner sc = new Scanner(System.in);
  6         System.out.println("请输入数字a的值");
  7         int a = sc.nextInt();// 第一次调用nextInt（）
  8         System.out.println("请输入数字b的值");
  9         int b = sc.nextInt();// 第二次调用nextInt（）
 10         int sum = a + b;
 11         System.out.println("输入数字："+a+"输入的数字：" + b +"的和是："+ sum);
 12     }
 13 }
 14

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Scanner;
  3 public class Demo05Scanner02Sum {
  4     public static void main(String[] args) {
  5         Scanner sc = new Scanner(System.in);
  6         System.out.println("请输入数字a的值");
  7         int a = sc.nextInt();// 第一次调用nextInt（）
  8         System.out.println("请输入数字b的值");
  9         int b = sc.nextInt();// 第二次调用nextInt（）
 10         System.out.println("请输入数字b的值");
 11         int c = sc.nextInt();// 第三次调用nextInt（）
 12         int temp = a > b ? a : b;// 三元运算符
 13         int max = temp > c ? temp : c;
 14         System.out.println("输入数字："+a+"输入的数字：" + b +"的和是："+ max);
 15     }
 16 }

1.3.匿名对象

一般来说：创建对象的标准格式：

类名称对象名 = new 类名称（）；

匿名对象就是只有右边的对象，没有左边的名字和运算符，且匿名对象只能用一次。

标准的对象如下图：

  1 package cn.itcast.demo01.demo01.demo05;
  2 public class Demo05person {
  3     public static void main(String[] args) {
  4         Person per = new Person();
  5         per.name = "高圆圆";// 变量赋值
  6         per.show();// 调用方法
  7     }
  8 }
  9

  1 package cn.itcast.demo01.demo01.demo05;
  2 
  3 public class Person {
  4     String name;
  5     public void show(){
  6         System.out.println("我叫：" + name);
  7     }
  8 }
  9

匿名对象只能用唯一一次

  1 package cn.itcast.demo01.demo01.demo05;
  2 public class Demo05person {
  3     public static void main(String[] args) {
  4         Person per = new Person();
  5         per.name = "高圆圆";// 变量赋值
  6         per.show();// 调用方法
  7         new Person().name = "赵又廷";
  8         new Person().show();// 结果是null，因为这是新对象，string默认null
  9     }
 10 }

匿名对象与常规对象的比对：可见，如果对象只用一次，匿名对象将简单许多。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Scanner;
  3 public class Demo05person {
  4     public static void main(String[] args) {
  5         // 常规对象使用
  6         Scanner sc = new Scanner(System.in);
  7         int a = sc.nextInt();
  8         System.out.println(a);
  9         System.out.println("========");
 10         // 匿名对象使用
 11         int b = new Scanner(System.in).nextInt();
 12         System.out.println(b);
 13     }
 14 }
 15

1.3.1.匿名对象是否可以作为方法的参数调用或方法的返回值呢？

当然可以

匿名对象进行传参时，使用匿名对象作为参数的方法的参数类型必须是匿名对象的类型，参数名称一般用匿名对象类型的简写，以便记忆。从而使用方法的参数名进行调用匿名对象的类型的自带方法，进一步完成方法的功能。

匿名对象作为返回值类型时，则该方法的返回值类型必须是匿名对象的类型，而在调用该方法时，需要重新创建对象并给予对象取名，从而使用匿名对象所属类的方法。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Scanner;
  3 public class Demo05person {
  4     public static void main(String[] args) {
  5         // 使用匿名对象传参
  6         scannerMethod(new Scanner(System.in));
  7         // 使用返回的匿名对象
  8         Scanner  sc = methodReturn();// 谁调用我，我就讲sc返回给谁
  9         int num = sc.nextInt();
 10         System.out.println("使用返回的匿名对象来创建的对象输入的值" + num);
 11     }
 12     public static void scannerMethod(Scanner sc){// 因为接受Scanner对象，所以参数类型就用Scanner sc
 13         int num  = sc.nextInt();// 调用方法nextInt，获取输入的值
 14         System.out.println("输入的是：" + num);// 打印输入的值
 15     }
 16     // 使用匿名对象作为返回值，既然是返回值匿名对象且是Scanner
 17     public static Scanner methodReturn(){  //返回值类型是匿名对象
 18 //        Scanner sc = new Scanner(System.in);// 常规创建对象
 19 //        return sc;
 20         return new Scanner(System.in);
 21     }
 22 
 23 }

2.Random类产生随机的数

引用类型，使用Random类也是三步；

导包 import java.lang.util.Random
创建 Random r = new Random（）；就是初始化其构造方法，random比较简单就两个构造方法。

使用比方说：t num = r.nextInt（）；

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Random;
  3 import java.util.Scanner;
  4 public class Demo05person {
  5     public static void main(String[] args) {
  6         Random r = new Random();
  7         int num = r.nextInt();
  8         System.out.println("随机数是："+num);
  9     }
 10 }
 11

Random中int类型的另外一个方法nextInt(int n) 参数n代表左闭右开开关int num = r.nextInt（3）代表的含义是【0,3）也就是0,1,2。类似于数组的长度。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Random;
  3 import java.util.Scanner;
  4 public class Demo05person {
  5     public static void main(String[] args) {
  6         Random r = new Random();
  7         for (int i = 0; i < 100; i++) {
  8             int num = r.nextInt(100);
  9             System.out.println("随机数字是：" + num);
 10         }
 11     }
 12 }
 13

练习：随机取 1-N的数字，也就是左闭右闭的区间。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Random;
  3 import java.util.Scanner;
  4 public class Demo05person {
  5     public static void main(String[] args) {
  6         Random r = new Random();
  7         for (int i = 0; i < 100; i++) {
  8             int num = r.nextInt(100)+ 1;
  9             System.out.println("随机数字是：" + num );
 10         }
 11     }
 12 }

练习：用代码模拟猜数字的小游戏

思路：1.首先产生一个随机数字，并且一旦产生不能变化，用Random的nextInt方法

2.需要键盘输入，使用Scanner，使用Scanner的nextInt方法

3.既然是比较数字猜没猜对，就可以用if，考虑是多循环，可以用while来进行

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Random;
  3 import java.util.Scanner;
  4 public class Demo05person {
  5     public static void main(String[] args) {
  6         Random r = new Random();
  7         int randomNum = r.nextInt(100)+1;
  8         Scanner sc = new Scanner(System.in);
  9         while(true){
 10             System.out.println("请输入你猜测的数字");
 11             int num = sc.nextInt();
 12             if (num > randomNum){
 13                 System.out.println("太大了");
 14             }else if(num < randomNum){
 15                 System.out.println("太小了");
 16             }else {
 17                 System.out.println("恭喜你，猜中了");
 18                 System.out.println("随机数是：" + randomNum);
 19                 break;
 20             }
 21         }
 22         System.out.println("游戏结束");
 23     }
 24 }
 25

假设使用指定次数猜测，则while不建议使用，我们可以用for循环。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Random;
  3 import java.util.Scanner;
  4 public class Demo05person {
  5     public static void main(String[] args) {
  6         Random r = new Random();
  7         int randomNum = r.nextInt(100)+1;
  8         Scanner sc = new Scanner(System.in);
  9         for (int i = 0; i < 10; i++) {
 10             System.out.println("请输入你猜测的数字");
 11             int num = sc.nextInt();
 12             if (num > randomNum){
 13                 System.out.println("太大了");
 14                 int a = 9 - i;
 15                 System.out.println("你还剩余"+ a + "次");
 16             }else if(num < randomNum){
 17                 System.out.println("太小了");
 18                 int a = 9 - i;
 19                 System.out.println("你还剩余"+ a + "次");
 20             }else {
 21                 System.out.println("恭喜你，猜中了");
 22                 System.out.println("随机数是：" + randomNum + "你使用了" + i + "次");
 23                 break;
 24             }
 25         }
 26         System.out.println("游戏结束");
 27     }
 28 }

3.对象数组

练习：定义一个数组，用来存储对象。

格式：对象类型【】数组名 = new 对象类型【】；对象数据的元素是地址值

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.Random;
  3 import java.util.Scanner;
  4 public class Demo05person {
  5     public static void main(String[] args) {
  6         // 常规数据类型的数组定义格式如下：
  7         int[] ar = new int[3];
  8         System.out.println(ar[0]);// 默认值是0
  9         //而对象数组呢；首先创建一个长度为3的数组，里面用来存放Person类型的对象
 10         Person [] array = new Person[3];
 11         System.out.println(array[0]);// 引用类型的默认值是null
 12         Person one = new Person("张欢",19);// one实际上地址值
 13         Person two = new Person("张欢",19);
 14         array[0] = one;// 将one当中的地址值给0号元素
 15         Person p = array[0];
 16         System.out.println(array[0].getName()+array[0].getAge());
 17         System.out.println(p.getName()+p.getAge());
 18     }
 19 }

  1 package cn.itcast.demo01.demo01.demo05;
  2 
  3 public class Person {
  4     private String name;
  5     private int age;
  6 
  7     public Person() {
  8     }
  9 
 10     public Person(String name, int age) {
 11         this.name = name;
 12         this.age = age;
 13     }
 14 
 15     public String getName() {
 16         return name;
 17     }
 18 
 19     public void setName(String name) {
 20         this.name = name;
 21     }
 22 
 23     public int getAge() {
 24         return age;
 25     }
 26 
 27     public void setAge(int age) {
 28         this.age = age;
 29     }
 30 }
 31

目前为止，我们想存储对象数据，选择的容器，只有对象数组。而数组的长度是固定的，无法适应数据变化的需求。为了解决这个问题，Java提供了另一个容器 java.util.ArrayList 集合类,让我们可以更便捷的存储和操作对象数据。而ArrayLst集合却可以。从名字可以看出，每个首字母大写，说明ArrayList是个类。

ArrayList<泛型> 集合名 = new Arraylist<>();

ArrayLIST<String> list = new ArrayList<java1.开始，此处可不写泛型>();

注意：泛型只能是引用类型，不能是基本类型，且list直接打印为空【】，不是地址值，特殊处理。参考后面toString（）方法。

java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。 ArrayList 中可不断添加元素，其大小也自动增长

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 import java.util.Scanner;
  5 public class Demo05person {
  6     public static void main(String[] args) {
  7         // 创建一个ArrayList集合，集合名字是list
  8         ArrayList<String> list = new ArrayList<>();
  9         // 打印ArrayList集合的名字list，结果为【】，此为内容，不是地址值。
 10         System.out.println(list);
 11 
 12         // 现在使用集合，向集合list中添加元素
 13         list.add("张华");
 14         list.add("李华");
 15         list.add("王华");
 16         list.add("胡华");
 17         System.out.println(list);// 结果是 [张华, 李华, 王华, 胡华] 逗号分隔
 18     }
 19 }
 20

造ArrayList对象时， <E> 指定了什么数据类型，那么 add(E e) 方法中，只能添加什么数据类型的对象。常用的方法是：

public boolean add<E e>：向集合中添加元素，参数类型和泛型一致。返回是否成功。

boolean success = list.add（“字符串”）；// boolean类型接收返回值

在ArrayList中，add动作一定成功，所以返回值可用可不用，但其他集合不一定。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 import java.util.Scanner;
  5 public class Demo05person {
  6     public static void main(String[] args) {
  7         // 创建一个ArrayList集合，集合名字是list
  8         ArrayList<String> list = new ArrayList<>();
  9         // 打印ArrayList集合的名字list，结果为【】，此为内容，不是地址值。
 10         System.out.println(list);
 11 
 12         // 现在使用集合，向集合list中添加元素
 13        boolean success = list.add("张华");
 14         list.add("李华");
 15         list.add("王华");
 16         list.add("胡华");
 17         System.out.println(list);// 结果是 [张华, 李华, 王华, 胡华] 逗号分隔
 18         System.out.println(success);
 19     }
 20 }

public E get(int index)：从集合中读取元素，参数是索引编号，返回值是对应位置的元素，接收的类型需要与泛型一致。

  1         String str = list.get(2);
  2         System.out.println(str);
  3         System.out.println(list.get(0));

public E remove(int index)：从集合中删除元素，参数是索引编号，返回值是被删除掉的元素，接收类型需要与泛型一致

  1         String who = list.remove(0);// 返回值是删除的元素
  2         System.out.println(who);// 返回删除的元素
  3         System.out.println(list);

public int size();获取集合的尺寸长度，返回值是集合中包含的元素个数，数组的长度点length是没有括号的，而集合点size有括号。

  1         int size = list.size();// 获取集合的长度
  2         System.out.println(size);

练习：遍历一个集合

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 import java.util.Scanner;
  5 public class Demo05person {
  6     public static void main(String[] args) {
  7         ArrayList<String> list = new ArrayList<>();
  8         list.add("大");
  9         list.add("小");
 10         list.add("中");
 11         list.add("微");
 12         for (int i = 0; i < list.size(); i++) {
 13             System.out.println(list.get(i));
 14         }
 15     }
 16 }
 17

3.3.yList集合中存放基本数据类型的办法

如果想在集合ArrayList中，存放基本数据类型，必须使用基本类型的对应的包装类。包装类与基本类型的对应关系。都在java.lang包下，不需要导入。

基本类型基本类型包装类
byte         Byte
short        Short
int           Integer
long         Long
ﬂoat         Float
double      Double
char         Character
boolean     Boolean

java1.5开始，支持自动包箱：基本类型→包装类型，支持自动拆箱：包装类型→基本类型

练习：包装类与集合联合成6个1-33的随机数，添加到集合，并遍历集合

1.随机数 Random类，2。整数添加到集合，包装类，3.遍历集合for

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 import java.util.Scanner;
  5 public class Demo05person {
  6     public static void main(String[] args) {
  7         Random r = new Random();
  8         ArrayList<Integer> list = new ArrayList<>();
  9         for (int i = 0; i < 6; i++) {
 10             list.add(r.nextInt(33)+ 1 );
 11         }
 12         for (int i = 0; i < list.size(); i++) {
 13             System.out.println(list.get(i));
 14         }
 15     }
 16 }

练习对象作为集合元素定义4个学生对象，添加到集合，并遍历。

1.自定义学生类，并创建4个对象

2.创建集合，并用add方法添加对象进集合中

3.遍历集合中的对象，需要用get方法，而返回值类型需要用对象原来类型创建对象接收get值。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 
  4 public class Demo05person {
  5     public static void main(String[] args) {
  6         ArrayList<Student> list = new ArrayList<>();
  7         // 创建4个对象
  8         Student one = new Student("冰",21);
  9         Student two = new Student("清",22);
 10         Student three = new Student("玉",23);
 11         Student four = new Student("洁",24);
 12         // 将4个对象放进集合中
 13         list.add(one);
 14         list.add(two);
 15         list.add(three);
 16         list.add(four);
 17         for (int i = 0; i < list.size() ; i++) {
 18             // 创建对象stu，指向list集合对应的对象
 19             Student stu = list.get(i);
 20             //
 21             System.out.println(stu.getName()+stu.getAge());
 22         }
 23 
 24 
 25     }
 26 }
 27

练习：集合作为参数，传递是地址值：定义一个打印集合的方法（而ArrayLst类型作为参数传递进打印方法中），结果使用{}扩起结果，使用@分割每个元素，格式参照{元素@元素@元素}

1.main中创建集合，并赋值；

2.创建方法使用集合作为传参，在方法内部进行遍历，

3.main中调用方法

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 
  4 public class Demo05person {
  5     public static void main(String[] args) {
  6         ArrayList<String> list = new ArrayList<>();//
  7         //
  8         list.add("张三丰");
  9         list.add("张无极");
 10         list.add("张大华");
 11         System.out.println(list);// 直接打印 [张三丰, 张无极, 张大华]
 12         printArrayList(list);
 13 
 14     }
 15     /*
 16     定义方法的三要素
 17     返回值类型  用void
 18     参数列表    集合 ArrayList
 19     方法名称  printArrayList
 20      */
 21     public static void printArrayList(ArrayList<String> list){// 泛型加上，保持一致
 22         System.out.print("{");
 23         for (int i = 0; i < list.size(); i++) {
 24             if (i == list.size() -1){
 25                 String str = list.get(i);
 26                 System.out.println(str+"}");
 27             }else {
 28                 String str = list.get(i);
 29                 System.out.print(str+"@");
 30             }
 31         }
 32     }
 33 }
 34

练习集合元素筛选的问题定义获取所有偶数元素集合的方法(ArrayList类型作为返回值)

用一个大集合，存入20个随机数字，然后筛选其中偶数的元素，并将偶数元素放入到小集合当中，要求使用自定义方法进行筛选。

1.创建大集合，Random类的20个随机数字，并输入。创建小集合

2.创建方法，遍历大集合，并将其中偶数放入小集合。

方法三要输：返回值类型集合，方法名称偶数，参数列表大集合。

3.输出小集合。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 
  5 public class Demo05person {
  6     public static void main(String[] args) {
  7         ArrayList<Integer> list = new ArrayList<>();//
  8         Random r = new Random();
  9         for (int i = 0; i < 20; i++) {
 10             int num = r.nextInt(100) + 1;// 100以内
 11             list.add(num);
 12         }
 13         // 原始随机值的集合
 14         System.out.println(list);
 15         // 偶数的值的集合
 16         System.out.println(getSmall(list));
 17     }
 18     public static ArrayList<Integer> getSmall(ArrayList<Integer> list){
 19         ArrayList<Integer> samlllist = new ArrayList<>();
 20         for (int i = 0; i < list.size(); i++) {
 21             int num = list.get(i);
 22             if (num % 2 == 0){
 23                 samlllist.add(num);
 24             }
 25         }
 26         return samlllist;
 27     }
 28 }
 29 
 30 
 31

4.String类 java.lang包中。

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。也就是说双引号的字符串，都是String类的对象。

字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。例如：

String str = "abc"; 等效于：不可变

char data[] = {'a', 'b', 'c'};  不可变

String str = new String(data); 不可变

字符串效果上相当于是char[]的字符数组，但底层原理是byte[] 字节数组。

4.1.创建字符串的3+1构造方法

public String() 初始化一个新创建的 String 对象，一个空字符序列。创建一个空白字符串
public String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。根据char字符数组的内容，来创建对应的字符串。
public String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。根据字节数组的内容，来创建对应的字符串。
String str = “hello“，这也是字符串对象。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 
  5 public class Demo05person {
  6     public static void main(String[] args) {
  7         //使用空参构造
  8         String str = new String();// 小括号留空，说明字符串内容都没有
  9         System.out.println("第一个字符串：" + str);
 10         // 使用字符数组创建字符串
 11         char[] array1 = {'a','b','c'};
 12         String str2 = new String(array1);
 13         System.out.println("第二个字符串：" + str2);
 14         // 使用字节数组创建字符串
 15         byte[] by = {97,98,99};
 16         String str3 = new String(by);
 17         System.out.println("第二个字符串：" + str3);
 18     }
 19 }
 20

4.2 字符串的常量池

字符串共享，就需要字符串的常量池。程序中直接写上双引号就在字符串常量池中。

4.3.字符串的常用方法-内容比较

==是用来进行字符串对象的地址值比较，那么如果需要进行内容的比较该如何进行呢，可以考虑使用两个方法来进行。

public boolean equals（Object obj）区分大小写，参数是任何对象类型。任何对象都能用object。只有参数是一个对象，且内容相同才会返回true，否则返回false；

注意事项 equals方法具有对称性，a.equals（b）和b.equals(a)一样。

equals方法中，建议常量点equals，否则出现null点equals会报错。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 
  5 public class Demo05person {
  6     public static void main(String[] args) {
  7         String str1 = "hello";
  8         String str2 = "hello";
  9         char[] charArray = {'h','e','l','l','o'};
 10         String str3 = new String(charArray);// 创建字符串对象，数组
 11         System.out.println(str1.equals(str2));// true
 12         System.out.println(str1.equals(str3));//true
 13         System.out.println(str3.equals(str2));// true
 14 
 15     }
 16 }
 17 
 18 
 19

public boolean equalsIgonreCase（Object obj）不区分大小写进行比较。参数是任何对象类型。任何对象都能用object。只有参数是一个对象，且内容相同才会返回true，否则返回false；

  1         String str4 = "Hello";
  2         System.out.println(str1.equalsIgnoreCase(str4));

4.3.字符串的常用方法-获取方法

public int length（）获取字符串中含有的字符个数，拿到字符串长度

public String concat（String str ）将当前字符串与参数字符串拼接新字符串且返回拼接。

public char charAt（int index）获取指定索引未知的单个字符（从0开始）。

public int indexOf（String str）查找参数字符串在本字符串当中首次出现的索引未知，如果没有返回-1.

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 
  5 public class Demo05person {
  6     public static void main(String[] args) {
  7         String str1 = "hello";
  8         String str2 = "hello";
  9         char[] charArray = {'h','e','l','l','o'};
 10         String str3 = new String(charArray);// 创建字符串对象，数组
 11         System.out.println(str1.length());// length（） 返回字符串长度
 12         System.out.println(str1.concat(str3));//concat进行拼接
 13         System.out.println(str1.charAt(1));// charAt方法获取索引1号的元素
 14         System.out.println(str1.indexOf('l'));// indexOf方法获取字符串的位置。没有返回-1
 15 
 16     }
 17 }
 18 
 19 
 20

4.4字符串的常用方法-截取方法

public String substring（int index）截取从参数未知开始一直到字符串结束

public String subString （int begin，int end）截取从begin开始，一直到end结束，中间的字符串。左闭右开区间【2,4）就是第三和第四个元素，没有第五个元素。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 
  5 public class Demo05person {
  6     public static void main(String[] args) {
  7         String str1 = "hello";
  8         String str2 = str1.substring(2);// 截取索引2以后字符，组成新字符串
  9         System.out.println(str1);
 10         System.out.println(str2);
 11         String str3 = str1.substring(1,3);// 截取索引1至2的字符，组成新字符串
 12         System.out.println(str1);
 13         System.out.println(str3);
 14     }
 15 }

4.5.符串的常用方法-转换方法

public char[] toCharArray(); 将当前字符串拆分成为字符数组作为返回值；

public byte[] getBytes();获得当前字符串底层的字节数组

public String replace（ CharSequence oldString ， CharSequence newString)将所有出现的老字符串体会成为新的字符串，返回替换后的结果是新字符串

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 
  5 public class Demo05person {
  6     public static void main(String[] args) {
  7         String str1 = "hello";
  8         char[] chars = str1.toCharArray();// 将当前字符串拆分成为字符数组作为返回值；
  9         System.out.println(chars);        //  打印
 10         System.out.println(chars.length);
 11         byte[] byte1 = str1.getBytes();// 获得当前字符串底层的字节数组
 12         System.out.println(byte1[0]);// 打印
 13 
 14        String str2 = "how do you do ?";
 15        //   将所有出现的老字符串体会成为新的字符串，返回替换后的结果是新字符串
 16        String str3 = str2.replace('o','w');
 17         System.out.println(str2);
 18         System.out.println(str3);
 19     }
 20 }
 21 
 22 
 23

4.5.符串的常用方法-分割方法

public String[] split（String regex）：按照参数的规则，将字符串分成若干部分，这个regex实际上是正则表达式，切割英文句点有问题。必须用\。来进行转义。

  1 package cn.itcast.demo01.demo01.demo05;
  2 import java.util.ArrayList;
  3 import java.util.Random;
  4 public class Demo05person {
  5     public static void main(String[] args) {
  6         String str = "aaa,bbb,ccc";
  7         String[] array1 = str.split(",");
  8 
  9         for (int i = 0; i < array1.length;i++) {
 10             System.out.println(array1[i]);
 11         }
 12     }
 13 }
 14

aaa
bbb
ccc

练习：定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。格式参照如下：[word1#word2#word3]。切记字符串相加就是拼接

  1 package cn.itcast.demo01.demo01.demo05;
  2 
  3 import java.util.ArrayList;
  4 import java.util.Random;
  5 
  6 public class Demo05person {
  7     public static void main(String[] args) {
  8         int[] array = {1, 2, 3,4};
  9         String str2 = fromString(array);
 10         System.out.println(str2);
 11         String str3 = "abc";
 12         String str4 = "abc";
 13         String str5 = str3 + str4;
 14         System.out.println(str5);
 15     }
 16     public static String fromString(int[] array){
 17         String str = "[";
 18         for (int i = 0; i <array.length; i++) {
 19             if(i == array.length - 1){
 20                 str +=  "word" + array[i] + "}";// 字符串相加就是拼接
 21             }else {
 22                 str +=  "word" + array[i] + "#";
 23             }
 24         }
 25         return str;
 26     }
 27 }

练习：键盘录入一个字符，统计字符串中大小写字母及数字字符个数

分析：既然是键盘输入，就有Scanner 其次键盘输入的是字符串 String str = sc.next（）；

定义四个变量，分别代表四种字符各自的出现次数。最后需要对字符串各个字进行检查，String→char[]，然后遍历char【】数组，对当前字符的种类进行判断，并且每个字符进行++动作。

  1 package cn.itcast.demo01.demo01.demo05;
  2 
  3 import java.util.ArrayList;
  4 import java.util.Random;
  5 import java.util.Scanner;
  6 
  7 public class Demo05person {
  8     public static void main(String[] args) {
  9         Scanner sc = new Scanner(System.in);
 10         System.out.println("请输入一串字符串：");
 11         String str = sc.next();
 12         count(str);
 13     }
 14     public static void count(String str){
 15         int a =0 ;
 16         int b =0;
 17         int c =0;
 18         int d =0;
 19         char[] ch = str.toCharArray();
 20         for (int i = 0; i < ch.length; i++) {
 21             char ch1 =  ch[i];
 22             if ('A'<= ch1 && ch1 <= 'Z'){
 23                 a++;
 24             }else if ('a'<= ch1 && ch1 <= 'z'){
 25                 b++;
 26             }else if ('0'<= ch1 && ch1 <= '9'){
 27                 c++;
 28             }else{
 29                 d++;
 30             }
 31         }
 32         System.out.println("大写字母统计个数是："+ a);
 33         System.out.println("小写字母统计个数是："+ b);
 34         System.out.println("数字统计个数是：" + c);
 35         System.out.println("其他字符统计个数是：" + d);
 36     }
 37 }
 38 
 39 
 40

需要注意的是，if括号内最好是单引号，另外字符串对比时，即便是数字也需要加引号。

5.静态方法

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

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

5.1.static关键字如何使用

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

static 数据类型变量名；

不建议使用对象点.类变量，因为后台也会编译为类名称.类变量

类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

修饰符 static 返回值类型方法名 (参数列表){ 方法体}

  1 package cn.itcast.demo01.demo01.demo05;
  2 
  3 public class Student {
  4     private int id ;// 学号
  5     private String name;// 姓名
  6     private int age;// 年龄
  7     static String room;// 教室
  8     private static int idCounter = 0; // 学号计数器，每当new一个新对象，计数器++
  9 
 10 
 11     public Student(String name, int age) {
 12         this.name = name;
 13 
 14         this.age = age;
 15         this.id = ++idCounter;// 当传参新建对象的时候，调用idCounter++
 16     }
 17 
 18     public Student() {
 19         idCounter++;
 20 
 21     }
 22 
 23     public int getId() {
 24         return id;
 25     }
 26 
 27     public void setId(int id) {
 28         this.id = id;
 29     }
 30     public String getName() {
 31         return name;
 32     }
 33 
 34     public void setName(String name) {
 35         this.name = name;
 36     }
 37 
 38     public int getAge() {
 39         return age;
 40     }
 41 
 42     public void setAge(int age) {
 43         this.age = age;
 44     }
 45 }
 46

  1 package cn.itcast.demo01.demo01.demo05;
  2 
  3 public class Demo05StaticField {
  4     public static void main(String[] args) {
  5         Student stu = new Student("黄蓉",19);
  6         Student stu2 = new Student("李蓉",29);
  7         stu.room = "1001教室";
  8         Student.room = "222";
  9         System.out.println("学号:" + stu.getId()+ ",姓名：" + stu.getName() + "，年龄：" + stu.getAge() + "，教室：" + stu.room);
 10         System.out.println("学号:" + stu2.getId()+ ",姓名：" + stu2.getName() + "，年龄：" + stu2.getAge() + "，教室：" + stu2.room);
 11     }
 12 
 13 
 14 }
 15

5.2.注意事项：

1.静态不能直接访问非静态；因为在内存当中是先有静态内容，再有非静态内容

2.静态方法当中不能用this，因为this代表当前对象，通过谁调用的方法，谁就是当前对象。但是静态与对象有关系么？没有关系，因此在静态方法中不能调用this关键字

5.3.静态的内容的内存图：

5.4.静态关键字static 还有一个特殊的用法叫静态代码块

静态代码块的格式：

public class 类名称{

static{

静态代码块

}}

特点就是：当第一次使用到本类时，静态代码块执行唯一的一次。

静态内容总是优先于非静态，也就是说静态代码将会比构造方法先执行。

典型用法：用来一次性的对静态成员变量进行赋值

6.Arrays数组工具类

java.util包中，java.util.arrays中提供了大量的静态方法，也就是不用new即可使用。用来实现数组常见的操作。

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。

默认格式：[元素1，元素2，，，，元素n]

public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

如果是数值，sort默认按照升序从小到大

如果是字符串包括中文，sort默认按照字母升序；

如果是自定义类型，自定义的类需要有comparable或comparator接口的支持

  1 package cn.itcast.demo01.demo01.demo05;
  2 
  3 import javax.print.DocFlavor;
  4 import java.util.Arrays;
  5 
  6 public class Demo05StaticField {
  7     public static void main(String[] args) {
  8         int[] intStr = {10, 20,30};
  9         // 调用Arrays中的toString方法
 10         String str1 = Arrays.toString(intStr);
 11         System.out.println(str1);
 12         System.out.println("-----");
 13         int[] array1 = {1,2,3};
 14         // 调用sort方法
 15         Arrays.sort(array1);// 无返回值
 16         System.out.println(Arrays.toString(array1));
 17         String[] str2 = {"bbb" , "ccc","aaa","abc"};
 18         System.out.println("-----");
 19         Arrays.sort(str2);
 20         System.out.println(Arrays.toString(str2));
 21     }
 22 }
 23

练习题：请使用Arrays相关的api，将一个随机字符串中的所有字符升序排列，并倒叙打印

分析：字符串首先录入 Scanner，要变成数组用toCharArray

数组使用sort排序

排序用for

  1 package cn.itcast.demo01.demo01.demo05;
  2 
  3 import javax.print.DocFlavor;
  4 import java.util.Arrays;
  5 import java.util.Scanner;
  6 
  7 public class Demo05StaticField {
  8     public static void main(String[] args) {
  9         Scanner sc = new Scanner(System.in);
 10         System.out.println("请输入一串字符串：");
 11         String str = sc.next();
 12         char[] chars = str.toCharArray();
 13         Arrays.sort(chars);
 14         System.out.println(chars);
 15         for (int i = chars.length - 1; i >= 0; i--) {
 16             System.out.print(chars[i]);
 17         }
 18     }
 19 }

7.Math数学工具类

public static double abs(double a) ：返回 double 值的绝对值。

public static double ceil(double a) ：返回大于等于参数的小的整，向上取整。

public static double floor(double a) ：返回小于等于参数大的整数，向下取整。

public static long round(double a) ：浮点数返回接近参数的 long。(相当于四舍五入方法)

练习：请使用 Math 相关的API，计算在 -10.8 到 5.9 之间，绝对值大于 6 或者小于 2.1 的整数有多少