Java_Day7接昨天ArrayList,String字符串，static关键字

如何存储基本类型数据类型：

ArrayList对象不能存储基本类型，只能存储引用类型，(整型） 不能写，但是存储基本类型我们可以选择它的包装类。

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

数值添加到集合：

生成6个1-33之间的随机数添加到集合中，并遍历一下

public static void main(String[] args) {
    //创建我们随机数对象
    Random random=new Random();
    //创建一个集合的对象
    ArrayList<Integer> arrayList=new ArrayList<>();
    //添加随机数到集合
    for (int i = 0; i <6; i++) {
        int r=random.nextInt(33)+1;
        arrayList.add(r);
    }
    for (int i = 0; i <arrayList.size() ; i++) {
        System.out.println(arrayList.get(i));
    }
}

自定义4个学生类对象添加到集合：

public static void main(String[] args) {
	//创建我们集合的对象        
	ArrayList<Student> arrayList=new ArrayList<>();
	//创建学生的对象        
    Student student1=new Student("哈登",30);        
    Student student2=new Student("威少",30);        
    Student student3=new Student("字母哥",25);        
    Student student4=new Student("肖华",50);
    //将学生的对象添加到我们的集合中      
    arrayList.add(student1);        
    arrayList.add(student2);        
    arrayList.add(student3);        
    arrayList.add(student4);
    //遍历一下我们的集合        
    for (int i = 0; i <arrayList.size(); i++) {
        Student student=arrayList.get(i);
        System.out.println(student.getName()+"‐‐‐‐‐"+student.getAge());        
	}    
}

打印集合的方法：
定义以制定的格式打印集合的方法（ArraList作为方法的参数），使用{}括起来的集合，使用@分割每一个元素，格式参数{元素@元素@元素}

public static void main(String[] args) {
    /*定义以制定的格式打印集合的方法（ArraList作为方法的参数），使用{}括起来的集合，使用@分割每一个元素，格式参数{元素@元素@元素}*/
    ArrayList<String> arrayList=new ArrayList<>();
    String str="哈登";
    String str1="威少";
    String str2="字母哥";
    arrayList.add(str);
    arrayList.add(str1);
    arrayList.add(str2);
    printArrayList(arrayList);
}
private static void printArrayList(ArrayList<String>arrayList) {
    System.out.print("{");
    //遍历我们的集合
    for (int i = 0; i < arrayList.size(); i++) {
        //获取我们的元素
        String str=arrayList.get(i);
        if(i!=(arrayList.size()‐1)){
            System.out.print(str+"@");
        }else{
            System.out.print(str+"}");
        }
    }
}

定义个获取所有偶数元素的集合的方法（ArrayList作为我们方法的返回值）:

public static void main(String[] args) {
    //定义获取所有偶数元素的集合的方法（ArrayList作为我们方法的返回值）
    //创建随机数的对象
    Random random=new Random();
    //创建我们的ArrayList集合
    ArrayList<Integer> arrayList=new ArrayList<>();
    //添加我们的随机数到集合中
    for (int i = 0; i <30; i++) {
    int r=random.nextInt(300)+1;
    arrayList.add(r);
	}
    ArrayList<Integer> arrayList1 = getArrayList(arrayList);
    System.out.println(arrayList1);
}
public static ArrayList<Integer> getArrayList(ArrayList<Integer> arrayList){
    //再创建一个集合存放我们的偶数
    ArrayList<Integer> arrayList1=new ArrayList<>();
    //遍历我们方法传过来的集合
    for (int i = 0; i <arrayList.size() ; i++) {
        //判断为偶数，添加到我们的新创建的集合中
        Integer num=arrayList.get(i);
        if(num%2==0){
        arrayList1.add(num);
        }
    }
    return arrayList1;
}

String类

1.1 String类概述

概述

java.lang.String类代表字符串

API当中说：Java程序中的所有字符串字面值(如"abc")都作为此类的实例实现。

其实就是说：程序当中所有的双引号字符串，都是String类的对象(就算没有new，也照样是)。

String类包括用于检查序列的各个字符的方法，用于比较字符串，搜索字符串，提取字符串以及创建将所有字符翻译为大写或小写的字符串的副本。

字符串的特点

1. 字符串的内容永不可变，字符串的值在创建后就不会发生变化。

   String s1 = "abs";
   s1 +="sd";
   System.out.println(s1);
   //内存中"abs","abssd"两个对象，刚开始s1指向的是"abs"，拼接完后，s1指向了新的地址"abssd"
   

2. 因为String对象是不可变的，所有它可以被共享。

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

   String str = "abc";
   //相当于
   char data[] = {'a','b','c'};String str = new String(data);
   

1.2 使用步骤

String在java.lang中，所有不需要导包

三种构造方法：

public String();创建一个空白字符串，不含任何内容

public String(char[] value);根据字符数组的内容，来创建对应的字符串。

public String(byte[] bytes);根据字节数组的内容，来创建对应的字符串。

public static void main(String[] args) {
    //无参构造创建一个字符对象
    String str = new String();
    //通过传字符数组构造字符串对象
    char[] charArray = {'A', 'B', 'C'};
    String str1 = new String(charArray);
    System.out.println(str1);//ABC
    //通过字节数组构造
    byte[] byteArray = {97,98,99};
    String str2 = new String(byteArray);
    System.out.println(str2);//abc
}

一种直接创建：

String str = "";

注意：直接写上双引号，就是字符串对象

字符串常量池

程序当中直接写上的双引号字符串，就在字符串常量池中

对应基本类型来说，==是进行数值的比较。

对于引用类型来说，==是进行地址值的比较。

双引号直接写的字符串在常量池当中，new的不在池当中。

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：

**一、**public boolean equals(Object obj):参数可以是任何对象，只有参数是一个字符串并且内容相同才会给true,否则返回false

注意事项：

1. 任何对象都能用Object进行接收。

2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。

3. 如果比较双方一个常量一个变量，推荐把常量字符写在前面。

   “abc”.equals(str5)推荐 str5.equals(“abc”)//不推荐

**二、**public boolean equalsIgnoreCase(String str):忽略大小写，进行内容比较。

public static void main(String[] args){
    String str1 = "hello";
    String str2 = "hello";
    String str3 = "hello";
    //equals方法，比较两个字符串是否相同
    String.out.println(str1.equals(str2));
    String.out.println(str1.equals(str3));
    //equalsIgnoreCase方法，比较两个字符串是否相同，忽略大小写
    String.out.println(str1.equalsIgnoreCase(str3));
}

常用方法

判断功能的方法

public int length():获取字符串当中含有的字符个数，拿到字符串长度。

//返回字符串的长度
String.out.println(str1.length());

public String concat(String str):将当前字符串和参数字符串拼接成为返回新的字符串。

//将制定字符串拼接到该字符串的尾部
String.out.println(str1.concat("12345"));

public char charAt(int index): 获取指定索引位置的单个字符。(索引从0开始。)

//返回指定索引处的char
String.out.println(str1.charAt(2));

public int indexOf(String str): 查找参数字符串在本字符串当中首次出现的索引位置，如果没有，返回-1.

String.out.println(str1.indexOf("12"));

截取功能的方法

public String substring(int index):截取从参数位置一直到字符串末尾，返回新字符串。

String.out.println(str1.substring(3));

public String substring(int begin, int end): 截取从begin开始，一直到end之间的字符。

String.out.println(str1.substring(3,6));

注意：[begin,end)

转换功能的方法

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

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

public String replace(CharSequence oldString,CharSequence newString);将所有出现的老字符串替换成新的字符串，返回替换之后的结果新字符串。

public static void main(String[] args){
    String s = "abcde";
    //将字符串转换成字符数组
    char[] chars = s.toCharArray();
    for(int i = 0; i < chars.length; i++){
        System.out.println(chars[i]);
    }
    byte[] bytes = s.getBytes();
    for(int i = 0; i < bytes.length; i++){
        System.out.println(bytes[i]);
    }
    //替换字符
    String str = "woaibiancheng";
    String replace = str.replace("a","A");
    System.out.println(replace);
}

分割功能的方法

public String[] split(String regex);按照参数的规则，将字符串切分成为若干部分

注意事项：

split方法的参数其实是一个"正则表达式"

如果按照英文句点"." 进行切分，必须写"\\."

拼接字符串

//定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串，格式按照如下：[word1#word2#word3]
public static void main(String[] args) {
    int[] arr = {1,2,3};
    String s = arrayToString(arr);
    System.out.println(s);
}
public static String arrayToString(int[] arr){
    String s = "[";
    //遍历数组拼接
    for (int i = 0; i < arr.length; i++) {
        if (i == arr.length-1){
            s = s.concat(arr[i]+"]");
        }else {
            s = s.concat(arr[i]+"#");
        }
    }
    return s;
}

统计字符个数

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个字符串：");
    String input = sc.nextLine();
    int countUpper = 0;
    int countLower = 0;
    int countNumber = 0;
    int countOther = 0;
    for (int i = 0; i < input.length(); i++) {
        //获取指定索引位置的单个字符
        char ch = input.charAt(i);
        if ('A' <= ch && ch <= 'Z'){
            countUpper++;
        } else if ('a' <= ch && ch <= 'z') {
            countLower++;
        } else if ('1' <= ch && ch <= '9') {
            countNumber++;
        } else {
            countOther++;
        }
    }
    System.out.println("大写字母有："+ countUpper);
    System.out.println("小写字母有："+ countLower);
    System.out.println("数字有："+ countNumber);
    System.out.println("其他字符有："+ countOther);
}

static关键字

概述：

​ 关于static关键字的使用，它可以修饰成员变量和成员方法，被修饰的成员属于类，而不是属于单单一个类，既然static这个修饰的东西属于类，那么调用的时候，就不需要创建对象去调用。

类变量：

当static修饰成员变量时，该变量属于类，该类中每个对象都共享同一个类的变量的值，任何对象都可以更改类变量的类，但是不可以在不创建对象的情况对类变量进行操作。

类变量

---

public class Student {
    private String name;
    private int age;
    private int sid;

    public static int numberStudent=0;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.sid = ++numberStudent;
    }

    public String toString(){
        return "Student{" +
                "name='" + name +'\''+
                ",age=" + age +
                ",sid=" + sid +
                '}';
    }
}

public static void main(String[] args) {
    Student student=new Student("哈登",30);
    Student student1=new Student("威少",29);
    Student student2=new Student("字母哥",30);
    System.out.println(student.toString());
    System.out.println(student1.toString());
    System.out.println(student2.toString());
    //类变量的调用：类名.类变量
    System.out.println(Student.numberStudent);
}

静态方法

---

当static修饰成员方法时，该方法称为类方法，静态方法在申明的时候用static

//静态方法（类方法）
public static void show(){
    System.out.println("num:"+numberStudent);
}
//调用类方法：类名.类变量();

注意事项：

1. 静态方法可以访问静态变量和静态方法
2. 静态方法不能直接访问成员变量和成员方法，反之，成员方法能直接访问静态变量和静态方法。
3. 静态方法不能使用this关键字

总结：静态的随着类的加载而加载，优于对象存在。静态方法只能访问静态成员。

1. 随着类的加载而加载，且只加载一次
2. 存储在我们的固定区域(静态区)，可以直接使用类名调用
3. 它优于对象存在，所以，所有的对象共享

静态代码块

---

静态代码块：定义在成员变量的位置，使用static修饰

格式：

static{}

位置：类中方法外

执行：随着类的加载而执行一次且只有一次，优于main方法和构造方法执行

public class Game{
    //类变量
    public static int number;
    public static ArrayList<String> list;
    //初始化
    static{
        //给类变量赋值
        number = 2;
        list = new ArrayList<>();
        list.add("abc");
        list.add("小白");
    }
    public static void main(String[] args) {
        System.out.println(Game.number);
    }
}

static关键字，可以修饰变量，方法和代码块，在使用过程中，其中目的就是不创造对象去直接调用。