华清远见——(JAVA高级阶段技术总结)

# String字符串

String是一个类，属于数据类型中的引用类型。

Java中一切使用""引起来的内容，都是这个类的实例，称为字符串对象。

**字符串**在定义后，值不可改变，是**一个常量**，实际是一个**字符数组**。

## 总结

在使用字符串时，如果要比较其值是否相同，不要使用==判断，因为==判断的是内存地址。

**所以在比较字符串是否相同时，要使用String类重写的equals方法进行判断。**

该方法判断的原理大致为：将两个字符串用字符数组保存，逐个判断字符数组中的每个字符，全部一致时返回true，

所以比较的是字面值。在使用equals方法时，通常将已知的非空字符串作为调用者。

```java
username.equals("admin");//这样写，username变量可能为空，会抛出空指针异常
"admin".equals(username);//这样写能避免空指针异常
```

# 可变字符串

String字符串对象是一个常量，在定义后，值不可改变。

如果使用String类的对象，对其频繁更新时，就会不停地创建新的对象，不停引用给同一个变量。

如要执行10000次循环重新赋值的过程，就要创建10000个字符串对象，执行效率很低，这时就需要使用可变字符串对象。

/*
 * 可变字符串StringBuilder
 * */
public class Test1 {
    public static void main(String[] args) {

        System.out.println("程序开始执行");
        //System.currentTimeMillis();用于获取当前时间对应的毫秒数
        //从1970 1 1 0:0:0这一刻开始，到这句话执行时间隔的毫秒数
        long startTime = System.currentTimeMillis();
        /*
        //循环"更新"字符串，实际是在不停创建新的字符串
        String str = "";
        for (int i = 0; i < 50000; i++) {
            str += i;
        }*/
        //使用可变字符串StringBuilder对象，真正更新字符串
        //因为全程只有一个对象StringBuilder，每次循环只是在不停操作该对象，不会创建新对象，所以效率很高
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 500000; i++) {
            sb.append(i);
        }
        long endTime = System.currentTimeMillis();

        System.out.println("程序执行结束,用时" + (endTime - startTime) + "毫秒");

    }
}

```

## StringBuilder类

用于表示可变字符串的一个类，是**非线程安全**的，建议在单线程环境下使用。

## StringBuffer类

用于表示可变字符串的一个类，是**线程安全**的，建议在多线程环境下使用。

StringBuilder和StringBuffer中的方法都一致，只不过StringBuffer中的方法使用了synchoronized关键字修饰，表示是一个同步方法，在多线程环境下不会出现问题。

这里以StringBuilder为例

         |

## 注意

-都是在直接操作同一个字符串对象，每次调用方法后，原字符串都会发生变化- StringBuffer和StringBuilder并没有重写equals方法，所以可变字符串的值是否相同时，调用的是equals中原始的==判断。如果要判断两个可变字符串的值是否相同时，需要将其转换为String后调用equals判断

**总结**

在频繁操作同一个字符串时，一定要使用可变字符串StringBuidler或StringBuffer类的对象，不能使用String类的对象。

# System类

这个类中包含了一些系统相关的信息和一些方法。其中的属性和方法都是静态的。

该类不能创建对象，不是因为它是一个抽象类，而是因为它的构造方法是私有的。                 |

# RunTime类

Runtime类的对象，表示**程序运行时对象**(程序运行环境对象)。

包含了程序运行环境相关的信息。常用于获取运行环境信息(如虚拟机内存)或执行某个命令。

## 特点

这个类不是一个抽象类，但不能创建对象，因为它的构造方法是私有的。

这个类提供了一个静态方法getRuntime()，通过这个方法，可以获取一个Runtime类的对象。

这是Java中的一种设计模式--单例模式(一个类只能有一个创建对象)。

```java
public class Runtime {
    //定义了私有的一个静态成员：当前类的对象
    //由于静态成员只在类加载时执行一次，所以这里只会创建唯一一个当前类的对象
    private static Runtime currentRuntime = new Runtime();

    //定义了一个公共的静态方法，用于获取创建的唯一的当前类的对象
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    //构造方法是私有的，不能在当前类之外创建对象
    private Runtime() {}
}
```

# 方法调用时传值问题

```java
package com.hqyj.test2;

public class Test {
    /*
     *  当方法的参数为原始类型，方法中对该参数做修改，不会影响实际参数
     * */
    public static void fun1(int i) {
        i = 123;
        System.out.println(i);
    }

    /*
     *  当方法的参数为字符串时，方法中对字符串"重新赋值"，实际是创建了一个新的字符串对象，不会影响实际参数
     * */
    public static void fun2(String str) {
        str = "new";
        System.out.println(str);
    }

    /*
     *  如果参数为引用类型，方法中直接操作该参数，操作的就是实际参数的内存地址，会影响实际参数
     * */
    public static void fun3(Person p) {
        p.setName("吴彦祖");
        System.out.println(p.getName());
    }

    /*
     * 如果参数为引用类型，方法中创建了一个新对象对其赋值，操作的是创建的新对象，不会影响实际参数
     * */
    public static void fun4(Person p) {
        p = new Person();
        p.setName("易烊千玺");
        System.out.println(p.getName());
    }

    /*
    * 如果参数为数组，也属于引用类型，方法中直接操作数组，操作的是实参数组，会影响实际参数
    * */
    public static void fun5(int[] list) {
        list[0] = 123;
        System.out.println(list[0]);
    }


    public static void fun(char[] list,Person p){
        list[0]='m';//这里在直接操作实际参数，会影响实参
        p = new Person();//这里创建了一个新的对象，操作的是方法中的对象，不会影响实参
        p.setName("刘鑫");
    }

    public static void main(String[] args) {
        //方法参数为原始类型，方法中对参数做修改，不会改变实际参数
        int i = 0;
        fun1(i);//123
        System.out.println(i);//0

        //方法参数为字符串，方法中对字符串重新赋值，不会改变实际参数
        String str = "old";
        fun2(str);//new
        System.out.println(str);//old

        //方法参数为引用类型，方法中对参数直接修改，会改变实际参数
        Person p = new Person();
        p.setName("王海");
        fun3(p);
        System.out.println(p.getName());

        //方法参数为引用类型，方法中创建新对象后赋值给实际参数，操作的是方法中的对象，不会改变实际参数
        Person p1 = new Person();
        p1.setName("赵敏");
        fun4(p1);
        System.out.println(p1.getName());

        //方法参数为数组，属于引用类型，方法中对参数直接修改，会改变实际参数
        int[] list = {0,1,2};
        fun5(list);
        System.out.println(list[0]);

        //练习
        char[] list2={'a','b','c'};
        Person p2 = new Person();
        fun(list2,p2);
        System.out.println(list2[0]);//m
        System.out.println(p2.getName());//null
    }
}

```

## 总结

**参数只有是引用类型(类、数组、接口),并且方法中在直接操作该参数时，才会对实际参数造成影响。**

fun3(Person p)参数为Person对象，方法中直接调用参数p的xxx方法，是在操作实际参数。

fun5(int[] list)参数为数组，方法中直接操作数组某个索引对应的元素，是在操作实际参数。

fun2(String str)和fun4(Person p)都在方法中创建了一个新的对象，是在操作方法中的参数，不影响实际参数。

          |

#  包装类
Java是纯面向对象语言，宗旨是将一切事物视为对象处理。但原始类型不属于对象，不满足面向对象的思想。但原始类型在使用时无需创建对象，保存在栈中，效率高。为了让原始类型也有对应的类类型，达到"万物皆对象"的理念，所以就有了包装类的概念。

**包装类就是原始类型对应的类类型**。包装类通常用于字符串与原始类型之间的转换。在web应用中，从浏览器页面中获取到后台的数据，全部都是String类型，所以一定要使用转换为原始
类型的方法。

##  特点

 - 八个原始类型中，除了int和char，其余类型的包装类，都是将首字母改为大写。int对于Integer,char对应Character
 - 包装类都是被final修饰的，不能被继承
 - 除了Character类，其余包装类都有两个构造方法：参数为原始类型或String的构造方法。
Character的构造方法只有一个，参数为char类型。这些构造方法用于将原始类型或字符串转换为包装类对象
 - 除了Character类，其余类都有静态方法parse原始类型(String str)，用于将字符串转换为相应的原始类型
   -   数值型的包装类的parseXXX()方法，如果参数不是对应的数字，转换时就会抛出
NumberFormat异常。如"123abc"，或"123.4"，在使用Integer.parseInt()时都会抛出异常
   - Boolean类型中的parseBoolean()方法，参数如果是"true"这四个字母，不区分大小写，都能转换为真正boolean类型的true，只要不是"true"这个单词，转换结果都为false
 - 除了Boolean类，其余包装类都有MAX_VALUE和MIN_VALUE这两个静态属性，用于获取对应类型支持的最大最小值
 - 所有包装类都重写了toString()方法，用于将包装类对象转换为String对象
 
# 异常
当程序没有按开发人员的意愿正常执行，中途出现错误导致程序中断，出现这种情况，就称为异常。
学习异常就是认识异常的种类，如何处理异常和避免异常出现。
## 异常的产生
异常在程序中以对象的形式存在。当代码执行过程中出现异常，虚拟机会自动创建一个异常对象，如果没有对象该异常对象进行处理，就会导致程序中断，不再执行后续代码。
##  处理异常
通常所说的处理异常，是指处理Exception类的子类异常。
处理异常的目的，就是保证程序正常执行。
###  方式一：try-catch-finally语句
这种方式处理异常，无论会不会抛出异常，都能让程序正常执行。

```java
try{
//可能出现异常的代码
}catch(异常类 异常对象){
//如果出现异常对象，且与catch小括号中的异常类型匹配，就会执行这里的代码
}catch(异常类 异常对象){
//如果出现异常对象，且与catch小括号中的异常类型匹配，就会执行这里的代码
}finally{
//无论程序是否会抛出异常，都要执行的代码
}
```

执行流程：先执行try中的代码，当出现异常，与后续catch中的异常类型进行匹配，如果匹配到对应的类型或异常父类型，则执行大括号中的代码，最终一定执行finally中的内容。

### 方式二：throws关键字
这种方式，可以让编译时异常通过编译。
在定义方法的时候，通过该关键字声明可能抛出的异常。
用法：方法的参数部分之后，添加"throws 异常类型1,异常类型2..."

```java
public class Test{
  public void fun() throws InterruptException{//这时该方法就会有一个声明：该方法可能
  会抛出异常
  //这句话直接写完后，会报错，因为sleep()方法可能会抛出InterruptException异常，属于
  编译时异常，必须要处理
  Thread.sleep(500);
  }
}
```

#### throw和throws

 - throws表示用于声明方法有可能出现的异常。使用时写在方法的小括号之后
 - throw用于手动抛出异常对象。使用时，写在方法体中，常用于满足某种情况时，强制中断程序
用法：throw 异常对象；

# 数组和集合

## 数组的特点

- 数组中保存的元素都是有序的，可以通过下标快速访问
- 数组中保存的数据都是同一种类型
- 数组的长度在定义后，无法改变
- 数组无法获取其中保存的元素实际数量

## 集合的特点

- 能保存一组数据，可以有序可以无序
- 集合的容量可变
- 集合中可以保存不同类型的数据
- 可以获取集合中保存的元素实际数量

# Collection接口

该接口有两个核心子接口：List和Set。

这两个接口都可以保存一组元素，List接口保存元素时，是有序可重复的；Set接口保存元素时，是无序不重复的。

## List接口(有序可重复)

有序集合，元素可以重复，允许保存null，可以通过索引获取对应位置上的元素。

在该接口继承Collection接口的同时，又拓展了一些操作元素的方法，如添加到指定索引、根据索引删除、获取指定索引的元素、截取子集合的方法等。

### ArrayList实现类(掌握)

- **采用数组实现的集合**
- 可以通过索引访问元素，可以改变集合大小。如果要在其中插入或删除元素时，会影响后续元素
- 该集合中保存的都是引用类型，即便保存了数组123，也保存的是Integer类型的123，而不是int类型的123
- 该集合查询效率高，中途增加和删除元素效率低

#### 常用方法

ArrayList中的常用方法，就是Collection接口和List接口中定义的方法。

### LinkedList实现类

- **采用双向链表实现的集合**
- 集合中保存的每个元素也称为节点，除首尾节点外，其余节点都保存了自己的信息外，还保存了其前一个和后一个节点的地址
- 如果在双向链表的数据结构中插入和删除操作节点时，不会影响其他节点的位置。如添加时新节点时，只需要重写定义新节点的前后节点位置即可
- 如果要查询某个节点时，需要从头结点或尾结点开始一步步得到目标节点的位置
- 双向链表在中间插入和删除的效率高，随机读取的效率低

### ArrayList和LinkedList的区别

- 这两个类都是List接口的实现类，保存的元素有序可重复，允许保存null
- ArrayList采用数组实现，随机读取效率高，插入删除效率低，适合用于查询
- LinkedList采用双向链表实现，插入删除时不影响其他元素，效率高，随机读取效率低，适合用于频繁更新集合

## Set接口(无序不重复)

无序集合，元素不可以重复，允许保存null，没有索引。

Set接口中没有自己定义的方法，都是继承于Collection接口中的方法

### 哈希表hash table

哈希表，也称为散列表，是一种数据结构，能更快地访问数据。

要保存的数据称为原始值，这个原始值通过一个函数得到一个新的数据，这个函数称为**哈希函数**，这个新数据称为**哈希码**，哈希码和原始值之间有一个映射关系，这个关系称为哈希映射，可以构造一张映射表，这个表称为哈希表。在哈希表中，可以通过哈希码快速地访问对应的原始值。

### HashSet实现类

- 采用哈希表实现
- 元素不能重复，无序保存，允许保存一个null
- 本质是一个HashMap对象
- 使用HashSet集合时，通常要重写实体类中的equals和hashcode方法

#### 常用方法

HashSet中没有属于自定义的方法，都是重写了父接口Set和Collection中的方法。这里参考Collection中的方法即可。

没有与索引相关的方法。

#### HashSet添加数据的原理

如果两个元素的hashCode相同且equals结果为true，视为同一个对象，不能添加。

每次向集合中添加元素时，先判断该元素的hashCode是否存在

- 如果不存在，视为不同对象，直接添加
- 如果存在，再判断equals方法的结果
  - 如果false，视为不同对象，可以添加
  - 如果true，视为同一对象，不能添加

由此可见，不能添加的条件是两个对象的hashCode相同且equals的结果为true。

如果每次只判断equals的话，由于equals方法通常重写时会判断很多属性，效率不高。

如果每次只判断hashCode的话，效率高，但有可能会有哈希冲突，

所以先判断hashCode，再判断equals，技能保证效率，又能保证不添加重复元素。

  

### TreeSet实现类

- 特殊的Set实现类，数据可以有序保存，可以重复，不能添加null
- 采用红黑树(自平衡二叉树)实现的集合
  - 二叉树表示某个节点最多有两个子节点
  - 某个节点右侧节点值都大于左侧节点值
  - 红黑树会经过不停的"变色"、"旋转"达到二叉树的平衡
- 只能添加**同一种类型**的对象且该类**实现了Comparable接口**
  - 实现Comparable接口后必须要重写compareTo()方法
  - 每次调用添加add(Object obj)方法时，就会自动调用参数的compareTo()方法
- compareTo()方法的返回值决定了能否添加新元素和新元素的位置
  - 如果返回0，视为每次添加的是同一个元素，不能重复添加
  - 如果返回正数，将新元素添加到现有元素之后
  - 如果返回负数，将新元素添加到现有元素之前
- 添加的元素可以自动排序

#### TreeSet的应用

如果要保存的元素需要对其排序，使用该集合。

保存在其中的元素必须要实现Comparable接口，且重写compareTo()方法，自定义排序规则

# Map接口

Map称为映射，数据以**键值对**的形式保存。保存的是键与值的对应关系。

键称为Key，值称为Value，键不能重复，键允许出现一个null作为键，值无限制。

键和值都是引用类型。

如，yyds就是一个键key，代表了一个含义：“永远单身”即为值value。

## HashMap实现类(掌握)


- JDK1.8之后，HashMap采用"**数组+链表+红黑树**"实现
  - 当没有哈希冲突时，元素保存到数组中
  - 如果出现哈希冲突，在对应的位置上创建链表，元素保存到链表中
  - 如果链表的长度大于8，将链表转换为红黑树
- 数据采用键值对key-value的形式保存，键不能重复，能用null作为键；值没有限制，键和值都是引用类型
- 向HashMap集合中添加元素时，原理同HashSet

### 常用方法

常用方法参考Map中的方法

# 遍历集合中元素的方式

## 遍历List集合

```java
ArrayList nameList = new ArrayList();
nameList.add("Tom");
nameList.add("Jerry");
nameList.add("LiHua");
nameList.add("Danny");
```

### 方式一：普通for循环

```java
System.out.println("使用普通for循环遍历");
//方式一：普通for循环
for (int i = 0; i < nameList.size(); i++) {//从0遍历到size()
    String name = nameList.get(i);//通过get(int index)获取指定索引的元素
    System.out.println(name);
}
```

### 方式二：增强for循环

```java
System.out.println("使用增强for循环遍历");
//方式二：增强for循环
for (String name : nameList) {
    System.out.println(name);
}
```

### 方式三：迭代器

```java
System.out.println("使用迭代器遍历");
//方式三：迭代器
//Collection类型的集合对象.iterator()，获取迭代器
Iterator iterator = nameList.iterator();
// iterator.hasNext()判断集合中是否还有下一个元素
// iterator.next();获取下一个元素
while (iterator.hasNext()) {
    String name = iterator.next();
    System.out.println(name);
}
```

## 遍历Set集合

```java
Set hs = new HashSet();
hs.add(123);
hs.add("hello");
hs.add(null);
hs.add(987);
```

### 方式一：增强for循环

```java
for(Object o : hs){
    System.out.println(o);
}
```

### 方式二：迭代器

```java
Iterator