java基础（3）java常用API

1 ArrayList集合

01 创建

import java.util.ArrayList;
/*
泛型:装在集合中的元素，全都是统一的一种类型。
泛型必须是引用类型，不能是基本数据类型
 */
 
public class ArrayDemo02 {
    public static void main(String[] args) {
        ArrayList<String> list01 = new ArrayList<>();//创建一个ArrayList集合，其元素全是String类型
        System.out.println(list01);//直接打印是值，不是地址
 
        list01.add("张三丰");
        System.out.println(list01);
        list01.add("张翠山");
        System.out.println(list01);//
        //list01.add(100);//错误写法，创建的时候<>泛型已经说了是String类型，所以所有元素必须写String
        list01.add("100");
        System.out.println(list01);
    }
}

02 常用方法和遍历

对于元素的操作,即——增、删、查。常用的方法有：
public boolean add(E e) ：将指定的元素添加到此集合的尾部。
public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

import java.util.ArrayList;
 
public class ArrayListMethod {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);
 
        //增-添加元素
        list.add("张三丰");
        list.add("张翠山");
        list.add("张无忌");
 
        //查-查找元素，读取元素
        System.out.println("get："+list.get(0));
        System.out.println("get："+list.get(1));
        System.out.println("get："+list.get(2));
 
        //删-删除元素
        System.out.println("remove："+list.remove(1));
 
        //遍历输出
        for (int i = 0; i < list.size(); i++) {
            System.out.println("遍历输出："+list.get(i));
        }
    }
}
//

[]
get：张三丰
get：张翠山
get：张无忌
remove：张翠山
遍历输出：张三丰
遍历输出：张无忌

03 ArrayList集合如何使用基本数据类型

ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似<int> 不能写，但是存储基本数据类型对应的
包装类型是可以的。所以，想要存储基本类型数据， <> 中的数据类型，必须转换后才能编写，转换写法如下：

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

import java.util.ArrayList;
 
public class ArrayListBasic {
    public static void main(String[] args) {
        //创建集合
        ArrayList<Integer> intList = new ArrayList<>();//只举Integer和long的例子
　　　　//错误写法：ArrayList<int> intList = new ArrayList<>();
        ArrayList<Long> longList = new ArrayList<>();
 
        intList.add(100);
        intList.add(200);
        intList.add(300);
 
        longList.add(400l);//需要加上L或者l，否则会报错
        longList.add(500L);
 
        System.out.println(intList.get(0));
        System.out.println(intList.get(1));
        System.out.println(intList.get(2));
 
        System.out.println(longList.get(0));
        System.out.println(longList.get(1));
    }
}
//

100
200
300
400
500

/*
训练1 数值添加到集合：创建一个集合，存储1-36之间的6个随机数
 */
import java.util.ArrayList;
import java.util.Random;
 
public class ArrayListTest01 {
    public static void main(String[] args) {
 
        ArrayList<Integer> intList = new ArrayList<>();
        Random r = new Random();
 
        for (int i = 0; i <5 ; i++) {
            intList.add(r.nextInt(36)+1);
        }
 
        System.out.println("打印全部："+ intList);
 
        System.out.println("遍历输出");
        for (int i = 0; i < intList.size(); i++) {
            System.out.println(intList.get(i));
        }
    }
}
 
//

打印全部：[28, 1, 15, 18, 9]
遍历输出
28
1
15
18
9

/*
训练2： 自定义一个学生类，添加到arraylist集合中，并且遍历打印相关信息
 */
public class ArrayListTest02 {
    public static void main(String[] args) {
        Person p1 = new Person("张三丰",99);//创建自定义对象
        Person p2 = new Person("张无忌",18);
        ArrayList<Person> personArrayList = new ArrayList<>();//创建ArrayList集合对象
 
        personArrayList.add(p1);//add方法：添加的元素和一个Person对象，即 ArrayList<Person>的<>中的自定义类型
        personArrayList.add(p2);
 
        for (int i = 0; i < personArrayList.size(); i++) {
            System.out.println(personArrayList.get(i));;//会输出两个对象的地址demo01.Person@1b6d358 demo01.Person@4554617c
            System.out.println((personArrayList.get(i)).getAge());
            System.out.println((personArrayList.get(i)).getName());
        }
    }
}
//

demo01.Person@1b6d3586
99
张三丰
demo01.Person@4554617c
18
张无忌

2 String 类

01 概述

String 类代表字符串。Java 程序中的所有字符串字面值（双引号括起来的字符串，如 "abc" ）都作为此类的实例实现。

字符串常量：

字符串是常量；它们的值在创建之后不能更改。

字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。例如：

     String str = "abc";
 

等效于：

     char data[] = {'a', 'b', 'c'};
     String str = new String(data);

字符串效果上等效于char[ ]字符数组："abc" 等效于 char[] data={ 'a' , 'b' , 'c' } 。但是在底层原理中是byte[ ]字节数组。

02 创建字符串

API中的三种构造方法：

public String() ：初始化新创建的 String对象，以使其表示空字符序列。
public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的
String。

// 无参构造
String str = new String（）；
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);

一种直接创建方法：

String s = ''abc'';//直接写上双引号，就是字符串对象。虽然没有食欲new，但是JVM就会创建对象了

03 字符串的常量池

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

对象str1和str2（由JVM自动创建）会重复利用常量池中的字符串。

但是自己new出来的对象str3不在常量池中。

04 字符串当中的常用方法

041 判断功能的方法（equals）

// == 是进行地址值的比较，如果确实想要进行内容的比较，可以使用两个方法：

public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小
写。

public class StringEquals {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String  str3 = "HELLO";
 
        System.out.println(str1 == str2);//true，地址一样
        System.out.println(str1.equals(str2));//true，内容一样
        System.out.println(str1.equals(str3));//false，大小写不一样
        System.out.println(str1.equals("hello"));//true
 
        System.out.println(str1.equalsIgnoreCase(str3));//true
    }
}

042 与获取相关的方法

public int length () ：返回此字符串的长度。
public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
public char charAt (int index) ：返回指定索引处的 char值。
public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符
串结尾。
public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到
endIndex截取字符串。含beginIndex，不含endIndex。

public class StringGetter {
    public static void main(String[] args) {
        //创建字符串对象
        String s1 = "helloworld";
 
        // int length():获取字符串的长度，其实也就是字符个数
        System.out.println(s1.length());//
        System.out.println("‐‐‐‐‐‐‐‐");
 
        // String concat (String str):将指定的字符串连接到该字符串的末尾.字符串是常量，拼接后是创建了新的对象，不会改变原来的字符串
        String s2 = "helloworld";
        String s3 = s2.concat("**hello Earth");
        System.out.println(s3);// helloworld**hello Earth
    }
}
//其他的方法类似

043 转换功能的方法

public char[] toCharArray () ：将此字符串转换为新的字符数组。
public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使
用replacement字符串替换。

public class StringReplace {
    public static void main(String[] args) {
        String s = "Hel";
 
        char[] c = s.toCharArray();
        System.out.println("length:"+c.length);
        for (int i = 0; i < c.length; i++) {
            System.out.println(c[i]);
        }
 
        byte[] by = s.getBytes();
        System.out.println("bytes:");
        for (int i = 0; i < by.length; i++) {
            System.out.println(by[i]);
        }
 
        String s2 = "会不会玩儿啊，你大爷的";
        String s3 = s2.replace("大爷","**");
        System.out.println(s3);
    }
}
///
length:3
H
e
l
bytes:
72
101
108
会不会玩儿啊，你**的

044 分割功能的方法

public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。返回值是字符串数组

public class StringSplit {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "aa,bb,cc";
        String[] strArray = s.split(","); // ["aa","bb","cc"]
        System.out.println(strArray.length);
        for(int x = 0; x < strArray.length; x++) {
            System.out.println(strArray[x]); // aa bb cc
        }
    }
}

三、static关键字

01 概述

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

格式：
static 数据类型 变量名；
如：
static int idStudent；

02 static关键字用于类属性

public class StaticField {
    public static void main(String[] args) {
        Student s1 = new Student("郭靖",20);
        s1.room = "101教室";
        System.out.println("name:"+s1.getName()
                +",age:"+s1.getAge()+",教室："+s1.room
                +",id:"+s1.getId());
        Student s2 = new Student("黄蓉",18);
        System.out.println("name:"+s2.getName()
                +",age:"+s2.getAge()+",教室："+s2.room
                +",id:"+s2.getId());
    }
}
//

name:郭靖,age:20,教室：101教室,id:1
name:黄蓉,age:18,教室：101教室,id:2

03static关键字修饰方法-静态方法

当static 修饰成员方法时，该方法称为类方法（习惯称为静态方法） 。

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

静态方法和成员方法的区别：

• 静态方法不属于对象，而是属于类的
• 成员方法必须创建对象来调用；
• 静态方法可以通过对象来调用，但是不推荐；推荐使用类名称来调用。

注意：

• 静态方法可以直接访问类变量和静态方法。
• 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
• 静态方法中，不能使用this关键字。（This 代表当前对象，但是静态方法不用创建对象来调用）
• 原因：内存当中是现有静态内容，后有非静态内容。先有的内容不能访问到后来出现的内容。

04 static的内存图

static 修饰的内容：

• 是随着类的加载而加载的，且只加载一次。
• 存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
• 它优先于对象存在，所以，可以被所有对象共享。

05 静态代码块

位置：类中方法外。
执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

格式：

public class ClassName{
static {
// 执行语句
}
}

作用：给类变量进行初始化赋值。

4 Arrays工具类

java.utils.Arrays包内：

常用的有以下几个方法：

public static String to String(数组) //将数组变成字符串
 
public static void sort（数组）//按照默认升序对数组元素排序

附录：java数据类型

一、八种基本数据类型（内置数据类型）：

1 四种整数类型(byte、short、int、long)

2 两种浮点数类型(float、double)

3 一种字符类型(char)：

4 一种布尔类型(boolean)

什么是JAVA的字面值

https://www.cnblogs.com/Parker-YuPeng/p/8520572.html

创建一个Hero对象会用到new关键字，但是给一个基本类型变量赋值却不是用new.

因为基本类型是Java语言里的一种内置的特殊数据类型，并不是某个类的对象。

给基本类型的变量赋值的方式叫做 字面值，如下所例：

float hp = 313f;
int armor = 24;

整数字面值、浮点数字面值、字符和字符串字面值（字符的字面值放在单引号中，字符串的字面值放在双引号中）

二、引用数据类型