Java基础--12.ArrayList,String,Math

一. ArrayList

1.1 概述

​ java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储

的元素。 ArrayList 中可不断添加元素，其大小也自动增长.

1.2 使用步骤

​ 1.2.1 查看类

​ java.util.ArrayList ：该类需要 import导入使后使用。

​ ，表示一种指定的数据类型，叫做泛型。 E ，取自Element（元素）的首字母。在出现 E 的地方，我们使用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素.

ArrayList<String>，ArrayList<Student>

​ 1.2.2 查看构造方法

​ public ArrayList() ：构造一个内容为空的集合

基本格式:

ArrayList<String> list = new ArrayList<String>();

​ 1.2.3 查看成员方法

​ public boolean add(E e) :将指定的元素添加到此集合的尾部.

​ 参数E e,在构造ArrayList对象时, 指定了什么数据类型,那么add(E e)方法中,只能添加什么数据类型的对象.

ArrayList<String> list = new ArrayList<>();
//创建学生对象
String s1 = "曹操";
String s2 = "刘备";
String s3 = "孙权";
//把学生对象作为元素添加到集合
list.add(s1);
list.add(s2);
list.add(s3);

​ 1.2.4 常用方法和遍历

​ 对于元素的操作,基本体现在——增、删、查。常用的方法有:

​ public boolean add(E e) ：将指定的元素添加到此集合的尾部。

​ public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。

​ public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。

​ public int size() ：返回此集合中的元素数.遍历集合时,可以控制索引范围,防止越界.

 ArrayList<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//public E get(int index):返回指定索引处的元素
System.out.println("get:"+list.get(0));
System.out.println("get:"+list.get(1));
System.out.println("get:"+list.get(2));
//public int size():返回集合中的元素的个数
System.out.println("size:"+list.size());
//public E remove(int index):删除指定索引处的元素，返回被删除的元素
System.out.println("remove:"+list.remove(0));
//遍历输出
for(int i = 0; i < list.size(); i++){
    System.out.println(list.get(i));
}

​ 1.2.5 如何存储基本数据类型

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

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

二. String

2.1 概述

​ java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实

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

2.2 使用步骤

​ 查看构造方法:

​ String() 创建一个空的字符串对象

​ String(String original) 根据字符串来创建一个字符串对象

​ String(char[] value) 通过字符数组来创建字符串对象

​ String(byte[] bytes) 通过字节数组来构造新的字符串对象

​ String(byte[] bytes, int offffset, int length) 通过字节数组一部分来构造新的字符串对象

public static void main(String[] args) { 
    // 1.String() 创建一个空的字符串对象 
    String str1 = new String(); 
    System.out.println("str1:" + str1); 
    // 2.String(String original) 根据字符串来创建一个字符串对象 
    String str2 = new String("abc"); 
    System.out.println("str2:" + str2); 
    // 3.String(char[] value) 通过字符数组来创建字符串对象 
    char[] chs = {'A', 'B', 'C', 'D', 'E'}; 
    String str5 = new String(chs); 
    System.out.println("str5:" + str5); 
    // 4.String(byte[] bytes) 通过字节数组来构造新的字符串对象 
    byte[] bytes = {97, 98, 99, 100, 101}; // a, b, c, d, e 
    String str3 = new String(bytes); 
    System.out.println("str3:" + str3); 
    // 5.String(byte[] bytes, int offset, int length) 通过字节数组一部分来构造新的字符串对象 
    String str4 = new String(bytes, 1, 2); 
    System.out.println("str4:" + str4); 
    String str6 = "abcde"; 
    System.out.println("str6:" + str6); 
}

2.3 特点

1. 字符串不变：字符串的值在创建后不能被更改。

   String s1 = "abc";
   s1 += "d"; 
   System.out.println(s1); // "abcd" 
   // 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。
   

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

String s1 = "abc"; 
String s2 = "abc"; 
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

2.4 常用方法

​ 2.4.1 判断功能的方法

​ public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。

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

public class String_Demo01 { 
    public static void main(String[] args) { 
        // 创建字符串对象 
        String s1 = "hello"; 
        String s2 = "hello"; 
        String s3 = "HELLO"; 
        // boolean equals(Object obj):比较字符串的内容是否相同 
        System.out.println(s1.equals(s2)); // true 
        System.out.println(s1.equals(s3)); // false 
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
        //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写 
        System.out.println(s1.equalsIgnoreCase(s2)); // true 
        System.out.println(s1.equalsIgnoreCase(s3)); // true 
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
    } 
}

​ 2.4.2 获取功能的方法

​ 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 String_Demo02 { 
    public static void main(String[] args) { 
        //创建字符串对象 
        String s = "helloworld"; 
        // int length():获取字符串的长度，其实也就是字符个数 
        System.out.println(s.length()); 
        System.out.println("‐‐‐‐‐‐‐‐"); 
        // String concat (String str):将将指定的字符串连接到该字符串的末尾
        String s = "helloworld"; 
        String s2 = s.concat("**hello itheima"); 
        System.out.println(s2);// helloworld**hello itheima 
        // char charAt(int index):获取指定索引处的字符 
        System.out.println(s.charAt(0)); 
        System.out.println(s.charAt(1)); 
        System.out.println("‐‐‐‐‐‐‐‐"); 
        // int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1 
        System.out.println(s.indexOf("l")); 
        System.out.println(s.indexOf("owo")); 
        System.out.println(s.indexOf("ak"));
        System.out.println("‐‐‐‐‐‐‐‐"); 
        // String substring(int start):从start开始截取字符串到字符串结尾 
        System.out.println(s.substring(0)); 
        System.out.println(s.substring(5)); 
        System.out.println("‐‐‐‐‐‐‐‐"); 
        // String substring(int start,int end):从start到end截取字符串。含start，不含end。 
        System.out.println(s.substring(0, s.length())); 
        System.out.println(s.substring(3,8)); 
    } 
}

​ 2.4.3 转换功能的方法

​ public char[] toCharArray () ：将此字符串转换为新的字符数组。

​ public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。

​ public String toLowerCase() ：使用默认语言环境的规则将此 String所有字符转换为小写。

​ public String toUpperCase() ：将此 String所有字符转换为大写，使用默认语言环境的规则。

​ public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串 使用replacement字符串替换。

public class String_Demo03 { 
    public static void main(String[] args) { 
        //创建字符串对象 
        String s = "abcde"; 
        // char[] toCharArray():把字符串转换为字符数组 
        char[] chs = s.toCharArray(); 
        for(int x = 0; x < chs.length; x++) { 
            System.out.println(chs[x]); 
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
        // byte[] getBytes ():把字符串转换为字节数组 
        byte[] bytes = s.getBytes(); 
        for(int x = 0; x < bytes.length; x++) {
            System.out.println(bytes[x]); 
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
        // 替换字母it为大写IT 
        String str = "itcast itheima"; 
        String replace = str.replace("it", "IT"); 
        System.out.println(replace); // ITcast ITheima 
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
    } 
}

​ 2.4.4 分割功能的方法

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

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

三. Math

​3.1 概述

​ java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

3.2 基本运算

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

double d1 = Math.abs(‐5); //d1的值为5 
double d2 = Math.abs(5); //d2的值为5

​ public static double ceil(double a) ：返回大于等于参数的最小的整数

double d1 = Math.ceil(3.3); //d1的值为 4.0 
double d2 = Math.ceil(‐3.3); //d2的值为 ‐3.0 
double d3 = Math.ceil(5.1); //d3的值为 6.0

​ public static double floor(double a) ：返回小于等于参数最大的整数。

double d1 = Math.floor(3.3); //d1的值为3.0 
double d2 = Math.floor(‐3.3); //d2的值为‐4.0 
double d3 = Math.floor(5.1); //d3的值为 5.0

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

long d1 = Math.round(5.5); //d1的值为6.0 
long d2 = Math.round(5.4); //d2的值为5.0