java 去中文括号中的内容 java中中括号是什么意思

ArrayList类

1.数组的长度不可以发生改变，但是ArrayList集合的长度是可以随意变化的。
2.对于ArrayList来说，有一个尖括号代表泛型。
泛型：也就是装在集合当中的所有元素，全都是同一的什么类型。
tip：泛型只能是引用类型，不能是基本类型。
3.一丢丢注意事项：
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容为空，得到的是空的中括号[]。

• 创建及使用：

// 创建了一个ArrayList集合，集合名称是list，里面装的全都是String字符串类型的数据。
 // 备注：从 JDK 1.7开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
 ArrayList<String> list = new ArrayList<>();
 System.out.println(list);// []
 
 // 向集合中添加一些数据，需要用到add方法。
 list.add("小明");
 System.out.println(list);// [小明]

list.add("Danny");
list.add("Li Ming");
System.out.println(list);// [小明, Danny, Li Ming]

ArrayList集合常用的方法和遍历

（1）常用的方法：

• public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。
  备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。但是对于其他集合来说（以后xue）来说，add添加动作不一定成功。
• public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。（索引值从0开始）
• public E remove(in index)：从集合当中删除元素，参数是索引编号，返回值就是被删除的元素。（索引值从0开始）
• public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。

栗子：

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    System.out.println(list);// []

    list.add("Jenny");
    list.add("Danny");
    list.add("Hanpi");
    list.add("Tiedan");
    System.out.println(list);// [Jenny, Danny, Hanpi, Tiedan]

    // 从集合中获取元素，：get。索引值从0开始
    String name = list.get(2);
    System.out.println("第2号索引位置是：" + name);// 第2号索引位置是：Hanpi

    // 从集合中删除元素:remove.
    String whoRemoved = list.remove(2);
    System.out.println("被删除的人是：" + whoRemoved);// 被删除的人是：Hanpi
    System.out.println(list);// [Jenny, Danny, Tiedan]

    // 获取长度
    int size = list.size();
    System.out.println("集合的长度是：" + size);// 集合的长度是：3
}

（2）遍历

栗子：

public static void main(String[] args) {
            // 创建一个list集合，并且添加一些数据
            ArrayList<String> list = new ArrayList<>();
            list.add("A");
            list.add("B");
            list.add("C");
            list.add("D");

            // 遍历输出 (list.fori)
            // 结果是A, B, C, D
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
                }
}

ArrayList集合存储基本类型数据

前提：如果希望向集合ArrayList中存储基本类型数据，必须使用进本类型对应的“包装类”。

基本类型	包装类（引用类型，包装类都位于java.lang包下）
byte	Byte
short	Short
int	Integer【特殊】
long	Long
float	Float
double	Double
char	Character【特殊】
boolean	Boolean

tip：从JDK 1.5开始，支持自动装箱，自动拆箱。

• 自动装箱：基本类型–》包装类型
• 自动拆箱：包装类型–》基本类型

栗子：

public static void main(String[] args) {
            // 创建
            ArrayList<Integer> listC = new ArrayList<>();

            // 添加数据
            listC.add(998);
            listC.add(648);

            // 获取数据
            int num0 = listC.get(0);
            int num1 = listC.get(1);
            System.out.println(num0);// 998
            System.out.println(num1);// 648
    }

字符串

• java.lang.String类代表字符串
• API当中说：Java程序中的所有字符串字面值（如“abc”）都作为此类的实例实现。
• 其实就是说：程序当中所有的双引号字符串，都是Sting类的对象。（就算没有new，也照样是。）

字符串的特点：
1.字符串的内容用不可变。【重点】
2.正是因为字符串不可改变，所以字符串是可以共享使用的。
3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

创建字符串的常见3+1种方式：
（1）三种构造方法：

• public String():创建一个空白字符串。
• public Stirng(char[] array):根据字符数组的内容，来创建对应的字符串。
• public String(byte[] array):根据字结数组的内容，来创建对应的字符串。

栗子：

public static void main(String[] args) {
            // 使用空参构造
            String str1 = new String();
            System.out.println(str1);

            // 根据字符数组创建字符串
            char[] charArray = { 'A', 'B', 'C' };
            String str2 = new String(charArray);
            System.out.println(str2);// ABC

            // 根据字节数组创建字符串
            byte[] byteArray = { 97, 98, 99 };
            String str3 = new String(byteArray);
            System.out.println(str3);// abc
    }

（2)一种直接创建：
String str = “viki”;
tip：直接写上双引号，就是字符串对象。

字符串的常量池

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。
tips：
1.对于基本类型来说，==是进行【数值】的比较。
2.对于引用类型来说，==进行的是【地址值】的比较。
3.双引号直接写的字符串在常量池当中，new的不在池当中。

栗子：

public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

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

        System.out.println(str1 == str2);// true
        System.out.println(str2 == str3);// false
        System.out.println(str1 == str3);// false
    }

字符串的比较相关方法

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：
1）public boolean equals(Objuct obj)：
参数可以是任何对象，只有参数是一个字符串并且内容相同的，才会给true，否则返回false。
注意事项：
1.任何对象都能用Object进行接收。
2.equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面。

• 推荐：“abc”.equlas(str)
• 不推荐：str.equals(“abc”)

2）public boolean equalsIgnoreCase(String str)：
忽略大小写，进行内容比较。

栗子:

String stra = "Abc";
        String strb = "abc";
        System.out.println(stra.equalsIgnoreCase(strb));// true

字符串的获取相关方法

• public int length()：获取字符串当中含有的字符个数，拿到字符串长度。
• public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。
• public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始）
• public int indexOf(String str)：查找字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

栗子：

public static void main(String[] args) {
            // 获取字符串长度
            int length = "Secret Garden".length();
            System.out.println(length);// 13
            
             // 拼接字符串
             String str1 = "hello";
             String str2 = "world";
             String str3 = str1.concat(str2);
             System.out.println(str1);// hello
             System.out.println(str2);// world
             System.out.println(str3);// helloworld
             
             // 获取指定索引位置的单个字符
             char c = "Secret".charAt(2);
             System.out.println(c);// c
             
             //查找字符串在本字符串当中首次出现的索引位置
             int index1 = "Secret Garden".indexOf("t G");
             int index2 = "Secret Garden".indexOf("abb");
             System.out.println(index1);// 5
             System.out.println(index2);// -1
    }

字符串的截取方法

• public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
• public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。
  备注：[begin,end)，包含左边，不包含右边。

栗子：

public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        String str3 = str1.substring(4,7);
        
        System.out.println(str2);// World
        System.out.println(str3);// oWo
        
        // 下面这种写法，字符串的内容是没有改变的
        // str4中保存的是地址值
        // 地址值由hello的地址值变成了it's me的地址值
        String str4 = "hello";
        System.out.println(str4);// hello
        str4 = "it's me";
        System.out.println(str4);// it's me
    }

字符串的转换相关方法

咳咳（字符数组：每个元素都是字符的数组。）

• public char[] toCharArray()：将当前字符串拆分为字符数组作为返回值。
• public byte[] getBytes()：获得当前字符串底层的字节数组。
• public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换为新的字符串，返回替换之后的结果新字符串。
  备注：CharSequence意思就是说可以接受字符串类型。

栗子：

public static void main(String[] args) {
        // 转换为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);// H
        System.out.println(chars.length);// 5 字符数组的lenth没有括号
        
         // 转化为字节数组
        byte[] bytes = "abcd".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);// 97 98 99 100
        }
        
        // 字符串的内容替换
        String str1 = "What do you mean?";
        String str2 = str1.replace("a", "*");
        System.out.println(str2);// Wh*t do you me*n?
    }

字符串的分割方法

• pubic String[] split(String regex)：按照参数的规则，讲字符串切分为若干部分。
  注意事项：
  split方法的参数其实是一个“正则表达式”，如果按照英文句点".“进行切分，必须写成”\."。

栗子：

public static void main(String[] args) {
        String str1 = "uuu,hhh,oooo,nn";
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);// uuu hhh oooo nn
        }
        
        String str2 = "aaa.bbb.ccc";
        String[] array2 = str2.split("\\.");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);// aaa bbb ccc
        }
    }

静态static关键字概述

• 简述：一旦用了static关键字，那么这样的内容不再属于对象自己，而是属于类的，所以凡是本类的对象，都共享同一份。
• 细讲：如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享一份数据。

static关键字修饰成员变量

Student类：

private String name;
    private int age;
    static String room;

主函数：

public static void main(String[] args) {
        // 学生一
        Student stu1 = new Student("Tommy",18);
        stu1.room = "101";// 直接赋值
        System.out.println("姓名：" + stu1.getName() + "，年龄："+ stu1.getAge() + "，教室：" + stu1.room);
        // 姓名：Tommy，年龄：18，教室：101
        
        // 学生二
        Student stu2 = new Student("viki",24);
        System.out.println("姓名：" + stu2.getName() + "，年龄："+ stu2.getAge() + "，教室：" + stu2.room);
        // 姓名：viki，年龄：24，教室：101
    }

静态static关键字修饰成员方法

• 一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
• 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
• 如果有了static关键字那么不需要创建对象，直接就能通过类名称来使用它。
• 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。

tips：
1.静态不能直接访问非静态。
原因：在内存当中，先有的静态内容，后有的非静态内容。（“先人不知道后人，但后人知道先人。”）
2.静态方法中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是对象。

栗子：

public class MyClass {
    int num;
    static int numStatic;
    // 成员方法
    public void method() {
        System.out.println("这是一个成员方法。");
    }
    // 静态方法
    public static void methodStatic() {
        System.out.println("这是一个静态方法。");
    }

}

主函数：

public static void main(String[] args) {
        // 首先创建对象
        MyClass obj = new MyClass();
        // 然后才能使用没有static关键字的内容
        obj.method();// 这是一个成员方法。
        
        // 对于静态方法来说，可以通过对象名来调用，也可以直接通过类名称类调用。
        // 正确，不推荐。这种写法在编译之后也会被javac翻译成为“类名称.静态方法”
        obj.methodStatic();// 这是一个静态方法。
        // 正确，推荐
        MyClass.methodStatic();// 这是一个静态方法。
    }

静态代码块

格式：

public class 类名称 {
    static {
    //静态代码块的内容
    }
}

特点：

• 当第一次使用到本类时，静态代码块执行唯一的一次。
• 静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

典型用途：
用来一次性地对静态成员进行赋值。

数组工具类Arrays

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

• public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2,
  元素3…]）。
• public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。

备注：
1.如果是数值，sort默认按照升序从小到大。
2.如果是字符串，sort默认按照字母升序。
3.如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（暂时不懂，以后学）

栗子：

public static void main(String[] args) {
        int[] array1 = {3, 5, 1, 6, 4, 9};
        // 将int数组按默认格式变成字符串。
        String intStr = Arrays.toString(array1);
        System.out.println(intStr);// [3, 5, 1, 6, 4, 9]
        
        // 排序
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));// [1, 3, 4, 5, 6, 9]
        
        String[] array2 = {"bac", "acb", "cbb"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));// [acb, bac, cbb]
    }

数学工具Math类

java.lang.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学相关的操作。

• public static double abs(double num)：获取绝对值
• public static double ceil(double num)：向上取整
• public static double floor(double num)：向下取整
• public static double round(double num)：四舍五入

Math.PI：近似的圆周率常量（double）

栗子：

public static void main(String[] args) {
        // 获取绝对值
        System.out.println(Math.abs(-2.1));// 2.1
        System.out.println(Math.abs(0));// 0
        System.out.println(Math.abs(6.3));// 6.3
        
        // 向上取整
        System.out.println(Math.ceil(4.2));// 5.0
        System.out.println(Math.ceil(-2.3));// -2.0
        
        // 向下取整
        System.out.println(Math.floor(6.7));// 6.0
        System.out.println(Math.floor(6.0));// 6.0
        
        // 四舍五入
        System.out.println(Math.round(3.4));// 3
        System.out.println(Math.round(3.5));// 4
        System.out.println(Math.round(-2.5));// -2
        System.out.println(Math.round(-2.6));// -3
    }

继承的概述

• 继承是多态的前提，如果没有继承，就没有多态。继承主要解决的问题就是：共性抽取。

父类：又叫基类、超类。
子类：又叫派生类。
特点：
1.子类可以拥有父类的“内容”。
2.子类还可以拥有自己专有的内容。

继承的格式

（在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类来看待。
例如：父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。）

定义父类的格式：

public class 父类名称 {
    // ...
}

定义子类的格式：

public class 子类名称 extends 父类名称 {
    // ...
}

继承中成员变量访问的特点

• 在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式。

1.直接：
通过子类对象访问成员变量（等号左边是谁，就优先用谁，没有则向上找。）
2.间接：
通过成员方法访问成员变量（该方法属于谁，就优先用谁，没有则向上找。）

父类：

public class Fu {

    int numFu = 10;
    int num = 100;
    .
    public void methodFu() {
        // 因为本类有num，所以这里用的是本类的num。
        System.out.println(num);// 100
    }
    
}

子类：

public static void main(String[] args) {
        Fu fu = new Fu();
        Zi zi = new Zi();
        
         // 方式一
        System.out.println(zi.num);// 父类和子类都有num，但是优先子类，结果是：200
        
        // 方式二
        // 这个方法是子类的，优先用子类的num，没有再向上找。
        zi.methodZi();// 200
        // 这个方法是在父类中定义的，所以用的是父类的num。
        fu.methodFu();// 100
        
    }

区分子类方法中重名的三种变量

局部变量	直接写成员变量名
本类的成员变量	this.成员变量名
父类的成员变量	super.成员变量名

栗子：
子类：

public class Zi extends Fu{

    int num = 20;
    
    public void method() {
        int num = 30;
        
        System.out.println(num);// 30
        System.out.println(this.num);// 20
        System.out.println(super.num);// 10
    }
}

父类：

public class Fu {

    int num = 10;
    
}

主函数：

public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }