2020-11-13javase总结

JAVASE基础总结

Java运行环境

1. 安装JDK文件，
2. 进入计算机环境变量
3. 添加新变量JAVA_HOME,变量值为JDK安装路径
4. 在变量Path中添加%JAVA-HOME%bin/%JAVA-HOME%jre/bin
5. Java -version版本
6. javac

Java了解

• JavaEE(企业)
• JavaSE（标准）
• JavaME（微型）

• jdk(Java开发工具包)

[Java Development kit]

• jre（Java运行环境）

[Java runtime environment]

• jvm(Java虚拟机)

[Java virtual machine]

执行一个程序，先去当前文档找文件，再去环境变量找

Java语法规则

1. 名称由：字母，数字，下划线，$组成；
2. 不能以数字开头；
3. 名字不能使用Java中的关键字；
4. 坚决不能出现中文；
5. 类名使用CamelCase风格，必须遵循驼峰式（首字母大写/首字母小写）；

一、基础数据类型

四类八种

• 整型： byte short int long（长整形）
• 浮点型： float（单精度） double （双精度）
• 布尔值： boolean
• 字符串： char

整形

正数的原码，反码，补码都是本身。

负数的反码，除了符号位，其余取反。

补码=反码+1

byte	1个字节(8)
short	2个字节
int	4个字节
long	8个字节

浮点型

float:	单精度（f）；32位
double	双精度(d)；64位

**1为正，0为负****

float`的内存表示指数位数有8位，范围是[0, 255]，考虑偏移量实际的指数范围是[-127,128]，不允许同时取0或者同时取1，也就是指数位的实际范围是[-126,127]，而指数取-127和128时有其特殊含义。

字符型

char	占2个字节
字符串	System.out.println(Integer.toBingary String(b));

布尔型

boolean	一个字节
boolean=flag	true/false

1、取值范围：

• 整型 ： byte -2^7 -> 2^7-1 10000000(-128) 其余的以此类推
• 浮点型 ： 符号位 + 阶码（指数） + 尾数
• char 一个字符连个字节 （unicode）

2、字符发展

ASCII（七位） -> ISO8859-1（单字节） -> unicode(两个字节) -> utf-8（可变长的字符集，英文 1个字节，中文3个字节）

GBK GB2312 中国的国标字符集

3、变量

变量的类型 变量的名字 = 具体的值；

• 定义和赋值两部分

• 他在内存里开辟了一片空间，可以存数据

• 他可以反复的到处使用

• 变量其实就是一个引用，他指向堆内存的一块区域，我们想操作一个对象只需要使用它的引用即可

4、标识符命名规则（名字）

• 可以用_和$但是不建议使用
• 可以用数字和字母，但是数字不能开头
• 不能使用关键字 super this class int double
• 所有的名字必须驼峰式命名，变量、方法首字母小写，类名首字母大写。静态常量全部大写多个单词用下划线分割。
• 尽量少用拼音，如果要用就整体都是拼音，不能拼音加因为，比如（isKong）

5、强制转化

整型里边小转大自动转，大转小需要强转，应为可能会都是精度

整型和浮点型：浮点型转整型需要强转，反之不需要，但是他以科学计数法表示可能会丢失精度

char能不能和整型转： 就是两个字节，随便转，就能当成一个short。但是char类型的变量经过计算都是int。任何short,byte,int,char无论是逻辑运算还是数学运算结果都是int；

// 会保存，计算结果都是int
byte m = 1;
byte n = 3;
byte c = m + n;

二、运算符

1、逻辑运算符

与 ：& 全部为真才是真，有一个是假就是假 串联电路 1 & 1 = 1； 0 & 0 = 0 ； 1& 0 = 0

或 ：| 全部为假才是假，有一个为真就是真 并联电路 1 | 1 = 1 ; 1 | 0 = 1; 0 | 0 = 0

非 : ! 非真即使假，非假就是真

异或： ^ 相同为假 ，不同为真 1^1 = 0 ; 0^0 = 0; 1^0 = 1

双与（ &&）：短路运算符， 前边为假直接返回假，后边的就不进行计算了 （常用）

双或 （ ||）：短路运算符， 前边为真直接返回真，后边的就不进行计算了（常用）

2、算术运算符

加 减 乘 除 取余（%）

1. 写在前边是先运算结果赋值后，执行其它。
2. 写在后边是先执行后赋值。

3、赋值运算符

• = ： 把后边的值赋给前边的变量
• ++ ： 自加一 arr[i++] 选运算，先把i给arr算，然后i=i+1 ; arr[++i] 选i=i+1，先把i给arr ； arr[i+1] 就是一个值i不会变
• -- ： 自减一
• += ： i += 6 如同与 i= i+6
• -= ：i -= 6 如同与 i= i-6

4、位移运算符

• >> 有符号右移 ,右移一位大致相当于什么除以2，除非溢出的末尾是零
• << 有符号左移，右移一位大致相当于什么乘以2，溢出的首位是零
• >>> 无符号右移

class HelloWorld{
    public static void main(String [] args){
        int a = 8 << 63; 
        System.out.println(a);  

        int r = 8 ^ 5;
        System.out.println(r);  
        
        
        short num3 = 130;
        byte num4 = (byte)num3;
        System.out.println(num4);

        byte num5 = 102;
        short num6 = num5;
        System.out.println(num6);
        
    }
}

5、三目运算符

• 条件 ？ 结果一 ： 结果二；

class HelloWorld{
    public static void main(String [] args){
        // condition ？ result1 : result2
            条件          结果1      结果2
        int res = 4>5 || true ? 6 : 9;
        System.out.println(res);
        
    }
}

三、流程控制语句

1、if条件控制语句

if (i == 0){
    
} else {
    
}

if (i == 0){
    
}
if (i != 2){
    
}

2、switch（开关）流程控制语句

// i可以是  byte short int String enum（枚举） 的数据
switch (i){
    case 1:
        System.out.println();
    break;
    case 2:
        System.out.println();
    break;
    default:
       ystem.out.println(); 
    break;
}

3、while循环语句

// 如果不是死循环，一定要相办法退出，退出机制
// 先判断满足条件才执行
boolean flag = true;
while (flag){
    
    if (如果达到某种条件){
        flag = false;
    }
}
// 死循环使用场景也挺多

do {} while (条件)   无论如何都要执行一次

4、do语句

• 先执行，然后判断，看要不要继续执行

do{
    System.out.println();
}while (i > 0);
    System.out.println();

5、for语句

int i = 0；
for (; i < 10;){

     i++;
}
// 1、定义了一个变量，这个变量可以定义在任何地方，只用作用域能访问到即可，
//    如果i定义在了方法里，他的作用域就是整个方法。如果定义在分号处，就只能在for循环内使用
// 2、进入的条件，这个条件能很复杂 （i !=4 || i != 7）只要结果是true或者false即可
// 3、一个条件，用于退出，不写就是没有条件，他就无法退出。i++ 能不能写在for循环内部，可以。
for (;;)  死循环

四、数组Array

1、定义

• 类型 名字[] = new 类型[长度]；
• 类型 名字[] = {1,2,3}
• 类型 名字[] ；名字 = new 类型[]{1,2,3,4}

2、特性

• 一旦创建就不能改变，类型不能改，长度不能改
• length代表他的长度
• 下标从零开始，最后一个是length-1
• 名字[下标] = 0；
• 如果使用时超出下标，ArrayIndexOutOfBoundsException;
• 数组里边可以是基本类型，也可以是引用类型

3、几个例子

必须要会的

遍历、取最大最小值、求和、交换

int temp = arrp[i];
arr[i] = arr[j];
arr[j] = temp;

4、数组

int [] nums = new int [6];
        nums [0] = 0;
        nums [1] = 1;
        nums [2] = 2;
        System.out.println(nums[2]);

5、数组FindMax

int[] nums = {2,3,1,9,6,4};
        
        int max = nums[0];
        for(int i = 1;i < nums.length;i++){
            if(nums[i] > max){
                max = nums[i];
            }
        }
        System.out.println(max);

6、数组FindMin

int[] nums = {2,3,1,9,6,4};
int min = nums[0];
        for(int i = 0;i < nums.length;i++){
            if(nums[i] < min){
                min = nums[i];
            }
        }
        System.out.println(min);

7、选择排序

int[] nums = {2,3,1,9,6,4};
        
        for (int j = 0;j < nums.length-1;j++){
            int min = j;
            for (int i = j+1;i < nums.length;i++){
                if (nums[i] < nums[min]){
                    min = i;
                }
            }
            int temp = nums[j];
            nums [j] = nums[min];
            nums [min] = temp;
    
        }
            
        
        for (int i = 0;i < nums.length;i++){
            System.out.println(nums[i]);

8、冒泡

int nums [] = {2,4,1,6,9,7};
        for(int j = 0;j < nums.length-1;j++){
            for(int i = 0;i  nums[i+1]){
                    
                    int temp = nums[i];
                    nums[i] = nums[i+1];
                    nums[i+1] = temp;
                }
            }
        }
        for(int i = 0;i < nums.length;i++){
            System.out.println(nums[i]);
        }

9、查找下标

    int nums [] = {2,4,1,6,9,7};
        int target = -1;
        for(int i = 0;i < nums.length;i++){
            if(nums[i] == 5){
                target = 1;
            }
        }
        System.out.println(target);

10、倒置（两极交换）

             int temp = 0;
                for (int i = 0; i < array.length/2 ; i++) {
                    temp = array[i];
                    array[i] = array[array.length-1-i];
                    array[array.length-1-i] = temp;
                }
                for (int i = 0; i < array.length ; i++) {
                    System.out.println(array[i]);
                }

11、求和

public class XcVm {
            public static void main(String[] args) {
                int array[] = {1,3,4,13,12,71,17,177,32};
//                求和，个位不能为7 十位不能为7 必须是偶数
                int sum = 0;
                for (int i = 0; i < array.length; i++) {
                    if ( array[i] % 10 != 7 && array[i] / 10 % 10 != 7 && array[i] % 2 == 0){
                        sum += array[i];
                    }
                }
                System.out.println(sum);
            }
        }

五、封装方法

权限修饰符 （static静态）(泛型) 返回值类型 名字（参数）{}

1、权限修饰符

作用域	当前类	同package	子孙类	其他package
public	√	√	√	√
protected	√	√	√	×
friendly	√	√		×
private	√	×		×

2、返回值类型

void 代表如返回值，能不能用return，能用代表终止方法；

3、static 不是必须的

静态方法和属性是属于类对象的的 ，使用时不需要new对象，直接 类名.方法名字(),类名.属性

实例方法（不带static） 先要new对象

4、名字，驼峰式首字母小写

5、参数

参数可以有多个，方法定义的地方叫形参，方法调用的地方传入的参数叫实参

6、可变参数:

• 只能出现一次
• 必须放在最后

public void f1 (int... nums)

7、方法的重载

• 方法名一样
• 参数列表不一样
• 每一个方法都有个签名 就是用名字和参数签名的

六、面向对象

1、封装

需要什么对象，就创建一个什么类，万物皆对象（就是我没有）

public class User{
    // 私有的属性
    
    // 构造器 可以没有 ，可以有一个，也可有duoge
    
    // 实例方法
    
    // getter and Setter
    
    // toString(如果需要)
} 

可能还有工具类和常量类，工具类里一般大多都是静态方法，常量类里大多是静态的常量

public static final String  ORDER_STATUS = "已发货";

1.1 属性

属性全部私有，使用getter取值，使用setter赋值、能做安全控制，比如我不想让别人设置值就不写setter，

1.2 方法

1.3 构造器

• new一个对象会主动调用他的构造器
• 构造器可有多个，可以有不同参数的构造器
• 构造器如果不写，或默认送你一个无参构造，一旦你写了有参构造方法，无参的就没有了，需要手写。

1.4值传递和引用传递的区别

使用基础数据类型时，会使用直传递。

引用传递，传进去的是内存地址 会改变指向对象的实际内容。

2、继承

• extends关键字，子类拥有父类（超类）一切（除了别private修饰的）。
• 构造子类是一定会先构造一个父类。
• 子类可以重写父类的方法。重写的方法需要加一个注解 @override
• Object是所有类的顶级父类

2.1重写（注解）

重写和重载的区别

重载：在一个类里面的两个方法，名字一样，参数列表不一个样。

重写：父亲里面的的方法，孩子继承了，但是不想要，然后重写了一个方法。 @Override 重写方法

2.2父子类构造问题

父类如果只有 有参构造器没有空参构造器 构造子类的时候必须

构造子类必须先构造一个父类，而且必须首先构造父类，必须是第一行。

 /*构造子类必须先构造一个父类，而且必须首先构造父类，必须是第一行
     */
    public Son(){
        super("烫头");
        System.out.println("123");
    }

super 指向父类

this 指向自己

object 指向顶级父类 所有类都会继承一个默认的顶级父类object，不用写也可以默认继承。

2.3insance of和对象转型

instanof 意思是实例 ，前面传的是对象，后面是类（class）

左边的对象 是否属于右边 的类

父 转 子 强转

子 转 父 自动转

一个子类不能继承多个父类。

3、多态

• 有继承
• 有重写
• 有父类引用指向子类对象

List list  = new ArrayList<>();
list.add(1)

3.1数据结构——链表

数组和链表的区别和优缺点总结

数组和链表是两种基本的数据结构，他们在内存存储上的表现不一样，所以也有各自的特点。

链表中各结点在内存中的存放位置是任意的。

链表与数组的主要区别

（1）数组的元素个数是固定的,而组成链表的结点个数可按需要增减;

（2）数组元素的存诸单元在数组定义时分配，链表结点的存储单元在程序执行时动态向系统申请:

（3）数组中的元素顺序关系由元素在数组中的位置(即下标)确定,链表中的结点顺序关系由结点所包含的指针来体现。

（4）对于不是固定长度的列表,用可能最大长度的数组来描述，会浪费许多内存空间。

（5）对于元素的插人、删除操作非常频繁的列表处理场合,用数组表示列表也是不适宜的。若用链表实现，会使程序结构清晰，处理的方法也较为简便。

例如在一个列表中间要插人一个新元素，如用数组表示列表，为完成插人工作，插人处之后的全部元素必须向后移动一个位置空出的位置用于存储新元素。

对于在一个列表中删除一个元素情况，为保持数组中元素相对位置连续递增，删除处之后的元素都得向前移一个位置。如用链表实现列表.链表结点的插人或删除操作不再需要移动结点，只需改变相关的结点中的后继结点指针的值即可，与结点的实际存储位置无关。

数组的特点

• 在内存中，数组是一块连续的区域。
• 数组需要预留空间，在使用前要先申请占内存的大小，可能会浪费内存空间。
• 插入数据和删除数据效率低，插入数据时，这个位置后面的数据在内存中都要向后移。
• 随机读取效率很高。因为数组是连续的，知道每一个数据的内存地址，可以直接找到给地址的数据。
• 并且不利于扩展，数组定义的空间不够时要重新定义数组。

链表的特点

• 在内存中可以存在任何地方，不要求连续。
• 每一个数据都保存了下一个数据的内存地址，通过这个地址找到下一个数据。 第一个人知道第二个人的座位号，第二个人知道第三个人的座位号……
• 增加数据和删除数据很容易。 再来个人可以随便坐，比如来了个人要做到第三个位置，那他只需要把自己的位置告诉第二个人，然后问第二个人拿到原来第三个人的位置就行了。其他人都不用动。
• 查找数据时效率低，因为不具有随机访问性，所以访问某个位置的数据都要从第一个数据开始访问，然后根据第一个数据保存的下一个数据的地址找到第二个数据，以此类推。 要找到第三个人，必须从第一个人开始问起。
• 不指定大小，扩展方便。链表大小不用定义，数据随意增删。

各自的优缺点

数组的优点

• 随机访问性强
• 查找速度快

数组的缺点

• 插入和删除效率低
• 可能浪费内存
• 内存空间要求高，必须有足够的连续内存空间。
• 数组大小固定，不能动态拓展

链表的优点

• 插入删除速度快
• 内存利用率高，不会浪费内存
• 大小没有固定，拓展很灵活。

链表的缺点

• 不能随机查找，必须从第一个开始遍历，查找效率低

3.2超级链表

package com.xinzhi;

/**
 * @author 
 * @date 2020/11/2
 */
public class SuperLink {
    private Node head;

    /**
     * 添加数据
     * @param data
     */
    public void add(Integer data){
//        1、让这个node变成头
       Node newHead = new Node(data,null);
//       2、让新的头指向旧的头
        newHead.setNext(head);
//     让新的头变成头
         head = newHead;

    }
    public void delete(int index){
        if (index == 0){
            Node node = getNode(index);
            head = node.getNext();
        }else {
            Node node = getNode(index-1);
            node.setNext(node.getNext().getNext());
        }
      Node node = getNode(index-1);
    }
    public Integer get(int index){
        return  getNode(index).getData();
        }
    public void update(int index,Integer newData){
        Node node = getNode(index);
        node.setData(newData);
    }

    private Node getNode(int index){
        Node node = head;
        for (int i = 0; i < index; i++) {
            node = node.getNext();
        }
        return node;
    }
    public void print(){
        Node node = head;
        while (node  != null){
            System.out.println(node.getData());
           node=node.getNext();
        }
    }
}

package com.xinzhi;

/**
 * @author 
 * @date 2020/11/2
 */
public class Node {
    private  int data;
    private Node next;

    public Node() {

    }

    public Node(int data, Node next) {
        /**
         * 具体存入的数据
         */
        this.data = data;
        /**
         * 指向下一个节点的引用
         */
        this.next = next;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", next=" + next +
                '}';
    }
}

package com.xinzhi;

/**
 * @author 
 * @date 2020/11/2
 */
public class Test {

    public static void main(String[] args) {
      SuperLink superLink = new SuperLink();
      superLink.add(2);
      superLink.add(3);
      superLink.print();
    }
}

3.3泛型

泛型，即“参数化类型”。最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。

顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

特性：

• 泛型：泛型只在编译阶段有效。

泛型类

• 泛型类型用于类的定义中，被称为泛型类。

• 通过泛型可以完成对一组类的操作对外开放相同的接口。

• 最典型的就是各种容器类，如：List、Set、Map。

  代表泛型

  package com.xinzhi.Super_Array;
  // 定义的super接口，在超级链表中实现接口。
  public interface Super {
           void add(T data);
           void delete(int index);
           T get(int index);
           void update(int index,T date);
           void print();
           int size();
  }
  

4、抽象类（abstract）和接口（interfa ce）

• 抽象类 : 拥有抽象方法的类，必须使用abstract修饰，可以有抽象方法，也可以没有。

​ 继承抽象类必须实现它的抽象方法。

• 接口：全部都是抽象方法（没有方法体的方法），interface

​ 实现接口（implements）必须实现所有的抽象方法

抽象类：既有抽象方法，也有具体的实现方法，也可以全部是抽象，也可以全部是实现。抽象方法需要关键字（abstract）来标明这个是抽象类。类是加在class前面，方法是加在返回值前面

接口方法：必须只有抽象方法，而且权限修饰符可以不用加，默认的是public，接口类需要关键字（interface）和（implements）来实现。接口方法：必须只有抽象方法，而且权限修饰符可以不用加，默认的是public，接口类需要关键字（interface）和（implements）来实现。

• 编程一定要面向接口编程。

5、Object的几个方法

• equals
• hashcode（hash算法）
• 重写equals必须重写hashcode，主要是因为有hashmap，hashset这类的集合
• toString()

6、this和super

this指向本实例

super指向父类的实例

this和super可以当构造器使用，但是如果想使用super()必须放在第一行；

7、类的加载顺序

1. 父类的静态属性
2. 父类的静态代码块
3. 子类的静态属性
4. 子类的静态代码块
5. 父类的非静态属性
6. 父类的非静态代码块
7. 父类的构造器
8. 子类的非静态属性
9. 子类的非静态代码块
10. 子类的构造器

(1).静态字段

public static String NAME = "父类的静态字段"

(2).静态代码块

// 类加载的时候就会调用
// 雷加载的时候 第一次主动使用就会加载这个类，就会把他加载到方法区内存里
static{
    System.out.println("静态的属性"+NAME); 
    System.out.println("父类的静态代码块");
}

(3).子类静态字段

public static String Name = "子类的静态字段"

(4).子类静态代码块

static{
    System.out.println("静态的属性"+NAME); 
    System.out.println("子类的静态代码块");
}

(5).父类的成员变量

private String hobby = "泡妞";

(6).父类的非静态代码块

// 非静态代码块
{
    System.out.println("父类的非静态属性"+hobby);
    System.out.println("父类的非静态代码块");
}

(7).父类的构造方法

public Father(){
    System.out.println("父类构造器");
}

(8).子类的成员变量

private String hobby = "电子游戏";

(9).子类的非静态代码块

// 非静态代码块
{
    System.out.println("子类的非静态属性"+hobby);
    System.out.println("子类的非静态代码块");
}

(10).子类的构造方法

public Son(){
    System.out.println("子类构造器");
}

8、类型强转

父类引用 -> 子类对象 不需要强转 向下转型

子类引用 -> 父类的对象 需要强转 向上转型

七、集合

集合是存东西的，能存很多同一种类型（包含他的子类）的对象。

1、Collection

2、list（列表）

• 需要定义泛型
• ArrayList LinkedList
• 区别：自己看

3、set

• set和list的区别
• list ：一个是有序的，可重复 有序说的是插入的顺序和实际的位置相关
• set : 一个是无序的，不可重复
• hashset怎么判断一个对象是不是重复的，equals和hashcode这两个方法，如果两个对象不是用一个地址但是他们equal，并且hashcode一样就说明一样。

.ArrayList和LinkedList

// 本质是一个数组
List list = new ArrayList<>();
// 本质是一个链表
List list = new LinkedList<>();

和HashMap的运行原理一样

内存存了:Value = object key = value next;

HashSet存放数字的时候会用value值当作存放位置的

用增强for循环遍历 因为他没有下标

for(Integer i:set){
    System.out.println(i);
}

利用Set将数组内的重复值全部删除

Set set = new HashSet<>(ist);
list = new SuperArray<>(set);

4、map（映射）

• 一听到hash就要想到无序
• hashmap最重要的集合，如果有兴趣可以看看我B站的hashmap源码解读，特别复杂。
• 存的是key，value键值对。
• hashmap的原理很重要，数据结构是数组+链表+红黑树

4.1HashMap()

// 存入键值对
    Map map = new HashMap<>();
    map.put("banzhang",new User("ccc",null));
    map.put("xuexi",new User("licuizhen",null));
    System.out.println(map.get("xuexi"));

存的值 key value next三个东西

申请一个数组，默认长度为16个，用到一个哈希算法。

用增强for循环遍历 因为他没有下标

不可以排序

4.2TreeMap();

自动排序，按照数字大小或者字符首字母a-z排序

Map map = new TreeMap();
map.put("banzhang",new User("赵六",null));
map.put("a组长",new User("王五",null));

输出：User{username="王五",password='null'}

​ User{username="赵六",password='null'}

5、自动排序的map

TreeTap：数据结构是红黑树，这种结构天然就是有序的，字符串会按照字典序排序。

TreeSet ：底层就是一个TreeMap

6、集合的遍历方式

list的遍历方式： 普通for循环，增强for循环，迭代器（iterator）

set的遍历方式：不能用普通for循环，只能用增强for和迭代器

// 增强for循环
for (Integer integer : set) {
    System.out.println(integer);
}
// 迭代器
Iterator iterator = set.iterator();
while (iterator.hasNext()){
    System.out.println(iterator.next());
}

hashmap的遍历方式： entrySet来遍历，还能用迭代器

// 第一种
for (Map.Entry entry : map.entrySet() ){
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
}
// 第二种
Set keys = map.keySet();
for (String key : keys) {
    System.out.println(map.get(key));
}
// 第三种迭代器
Iterator> iterator = map.entrySet().iterator();
while (iterator.hasNext()){
    Map.Entry next = iterator.next();
    System.out.println(next.getKey());
    System.out.println(next.getValue());
}

7、Iterator迭代器

循环遍历所有数组

HashSet set = new HashSet();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        set.add(5);
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            Integer next = iterator.next();
            iterator.remove();
            System.out.println(next);
        }

增强for循环不能调用Remove方法

Map遍历

Iterator>iterator =  new map.entrySet().iterator();
while(iterator.hasNext()){
   Map.Entry next = interator.next();
    System.out.println(next);
}

八、泛型

Java泛型设计原则：只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException异常.

泛型：把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

参数化类型:

• 把类型当作是参数一样传递
• <数据类型> 只能是引用类型

1、泛型类

泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来....这样的话，用户明确了什么类型，该类就代表着什么类型...用户在使用的时候就不用担心强转的问题，运行时转换异常的问题了。

• 在类上定义的泛型，在类的方法中也可以使用！

/*
    1:把泛型定义在类上
    2:类型变量定义在类上,方法中也可以使用
 */
public class ObjectTool {
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

用户想要使用哪种类型，就在创建的时候指定类型。使用的时候，该类就会自动转换成用户想要使用的类型了。

public static void main(String[] args) {
    //创建对象并指定元素类型
    ObjectTool tool = new ObjectTool<>();

    tool.setObj(new String("钟福成"));
    String s = tool.getObj();
    System.out.println(s);


    //创建对象并指定元素类型
    ObjectTool objectTool = new ObjectTool<>();
    /**
         * 如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.
         */
    objectTool.setObj(10);
    int i = objectTool.getObj();
    System.out.println(i);
}

2、泛型方法

前面已经介绍了泛型类了，在类上定义的泛型，在方法中也可以使用.....

现在呢，我们可能就仅仅在某一个方法上需要使用泛型....外界仅仅是关心该方法，不关心类其他的属性...这样的话，我们在整个类上定义泛型，未免就有些大题小作了。

• 定义泛型方法....泛型是先定义后使用的

    //定义泛型方法..
    public  void show(T t) {
        System.out.println(t);

    }

• 测试代码：

用户传递进来的是什么类型，返回值就是什么类型了

    public static void main(String[] args) {
        //创建对象
        ObjectTool tool = new ObjectTool();

        //调用方法,传入的参数是什么类型,返回值就是什么类型
        tool.show("hello");
        tool.show(12);
        tool.show(12.5);

    }

3、泛型类派生出的子类

前面我们已经定义了泛型类，泛型类是拥有泛型这个特性的类，它本质上还是一个Java类，那么它就可以被继承

那它是怎么被继承的呢？？这里分两种情况

1. 子类明确泛型类的类型参数变量
2. 子类不明确泛型类的类型参数变量

3.1 子类明确泛型类的类型参数变量

• 泛型接口

/*
    把泛型定义在接口上
 */
public interface Inter {
    public abstract void show(T t);

}

• 实现泛型接口的类.....

/**
 * 子类明确泛型类的类型参数变量:
 */

public class InterImpl implements Inter {
    @Override
    public void show(String s) {
        System.out.println(s);

    }
}

3.2 子类不明确泛型类的类型参数变量

• 当子类不明确泛型类的类型参数变量时，外界使用子类的时候，也需要传递类型参数变量进来，在实现类上需要定义出类型参数变量

/**
 * 子类不明确泛型类的类型参数变量:
 *      实现类也要定义出类型的
 *
 */
public class InterImpl implements Inter {

    @Override
    public void show(T t) {
        System.out.println(t);

    }
}

测试代码:

public static void main(String[] args) {
    //测试第一种情况
    //Inter i = new InterImpl();
    //i.show("hello");

    //第二种情况测试
    Inter ii = new InterImpl<>();
    ii.show("100");

}

值得注意的是：

• 实现类的要是重写父类的方法，返回值的类型是要和父类一样的！
• 类上声明的泛形只对非静态成员有效

---

4、 类型通配符

为什么需要类型通配符？？？？我们来看一个需求.......

现在有个需求：方法接收一个集合参数，遍历集合并把集合元素打印出来，怎么办？

• 按照我们没有学习泛型之前，我们可能会这样做：

public void test(List list){
    for(int i=0;i

上面的代码是正确的，只不过在编译的时候会出现警告，说没有确定集合元素的类型....这样是不优雅的...

• 那我们学习了泛型了，现在要怎么做呢？？有的人可能会这样做：

public void test(List