Java学习笔记⑭（包装类（装箱、拆箱，自动装箱与自动拆箱，基本类型与字符串之间的转换），Collection集合（集合概述，集合框架介绍，Collection集合常用功能），Iterator迭代器）

一、包装类

1. 包装类的概念

• 基本类型对应的包装类：
  

• 装箱：把基本类型的数据，包装到包装类中（基本数据类型->包装类）

1. 构造方法：

• Integer(int value) 构造一个新分配的Integer对象，它表示指定的int值。
• Integer(String s)构造一个新分配的Integer对象，它表示String参数所指示的int值。
• 传递的字符串，必须是基本类型的字符串，否则会抛出异常"100"正确 “a” 抛异常。

2. 静态方法

• static Integer valueOf(int i) 返回一个表示指定的int值的Integer实例。
• static Integer valueOf(String s) 返回保存指定的String的值的Integer对象。

• 拆箱：在包装类中取出基本类型的数据（包装类->基本类型的数据）
• 成员方法：
  int intValue() 以int类型返回该Integer的值

package day15.demo01;

public class Demo01Integer {
    public static void main(String[] args) {
        //把基本类型的数据，包装到包装类中（基本数据类型->包装类）
        //构造方法
        Integer in1 = new Integer(1);//方法上面有横线，说明方法过时了
        System.out.println(in1);//1 重写了toSting方法

        Integer in2 = new Integer("1");
        System.out.println(in2);//1

        //静态方法
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3);

        //Integer in4 = Integer.valueOf("o");//NumberFormatException数字格式化异常
        Integer in4 = Integer.valueOf("1");
        System.out.println(in4);

        //拆箱：在包装类中取出基本类型的数据（包装类->基本类型的数据）
        int i = in1.intValue();
        System.out.println(i);
    }
}

运行结果：

2. 自动装箱与自动拆箱

• 自动装箱与自动拆箱：基本类型的数据和包装类之间可以自动的相互转换
• JDK1.5之后出现的新特性

package day15.demo01;

import java.util.ArrayList;

public class Demo01Integer01 {
    public static void main(String[] args) {
        //自动装箱：直接把int类型的整数赋值包装类
        //Integer in =1; 就相当于Integer in = new Integer(1);

        Integer in = 1;
        /*
            自动拆箱：in是包装类，无法直接参与运算，可以自动转换为基本数据类型，再进行计算
            in+2;就相当于in.intValue()+2=3
            in = in.intValue() + 2 = 3 又是一个自动装箱
        */
        in = in+2;
        ArrayList<Integer> list = new ArrayList<>();
        /*
          ArrayList集合无法直接存储整数，可以存储Integer包装类
        */
        list.add(1);//-->自动拆箱 list.add(new Integer(1));
        int a = list.get(0);//-->自动拆箱 list.get(0).intValue();
    }
}

3. 基本类型与字符串之间的转换

• 基本类型->字符串（String）

1. 基本类型的值+"" 最简单的方法（工作中常用）
2. 包装类的静态方法toString(参数)，不是Object类的toString()重载

• static String toString(int i)返回一个表示指定的整数的String对象

3. String类的静态方法valueOf(参数)

• static String valueOf(int i) 返回int参数的字符串表示形式。

• 字符串(String)->基本类型

• 使用包装类的静态方法parseXXX(“字符串”);
• Integer类：static int parseInt(String s)
• Double类：static double parseDouble(String s)

package day15.demo01;

public class Demo01Integer02 {
    public static void main(String[] args) {
        //基本类型->字符串（String）
        int i1 = 100;
        String s1 = i1+"";
        System.out.println(s1+200);//1002000

        String s2 = Integer.toString(100);
        System.out.println(s2+200);//100200

        String s3 = String.valueOf(100);
        System.out.println(s3+200);//100200

        //字符串(String)->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i-10);

//        int a = Integer.parseInt("a");//NumberFormatException
//        System.out.println(a);
    }
}

运行结果：

二、Collection集合

1. 集合的概述

• 集合：集合是java中提供的一种容器，可以用来存储多个数据。
• 集合与数组的区别

• 数组的长度是固定的。集合的长度是可变的。
• 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

2. 集合框架介绍

3. Collection集合常用功能

• Java.util.Collection接口

• 所有单列集合的最顶层的接口，里边定义了所有单列集合共性的方法
• 任意的单列集合都可以使用Collection接口中的方法

• 共性的方法：

• public boolean add(E e): 把给定的对象添加到当前集合中。
• public void clear():清空集合中所有的元素，但是不删除集合，集合还存在
• public boolean remove(E e):把给定的对象在当前集合中删除。
• public boolean contains(E e):判断当前集合中是否包含给定的对象。
• public boolean isEmpty():判断当前集合是否为空。
• public int size():返回集合中元素的个数。
• public Object[] toArray():把集合中的元素，存储到数组中。

package day15.demo02;

import java.util.ArrayList;
import java.util.Collection;

public class Demo02Collection {
    public static void main(String[] args) {
        //创建结合对象，可以使用多态
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);//重写了toString方法 []
        /*
            public boolean add(E e): 把给定的对象添加到当前集合中
            返回值是一个boolean值，一般都是返回true,所以可以不用接收
         */
        boolean b1 = coll.add("张三");
        System.out.println("b1:"+b1);//b1:true
        System.out.println(coll);//[张三]
        coll.add("李四");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll);//[张三, 李四, 赵六, 田七]

        /*
            public boolean remove(E e):把给定的对象在当前集合中删除。
            返回值是一个boolean值，集合中存在元素，删除元素，返回True
                               集合中不存在元素，删除失败，返回False
         */
        boolean b2 = coll.remove("赵六");
        System.out.println("b2:"+b2);//b2:true

        boolean b3 = coll.remove("赵四");
        System.out.println("b3:"+b3);//b3:false
        System.out.println(coll);//[张三, 李四, 田七]

        /*
            public boolean contains(E e):判断当前集合中是否包含给定的对象。
            包含返回True
            不包含返回False
         */
        boolean b4 = coll.contains("李四");
        System.out.println("b4:"+b4);//b4:true

        boolean b5 = coll.contains("赵四");
        System.out.println("b5:"+b5);//b5:false

        //public boolean isEmpty():判断当前集合是否为空。集合为空返回True，集合不为空返回False
        boolean b6 = coll.isEmpty();
        System.out.println("b6:"+b6);//b6:false

        //public int size():返回集合中元素的个数
        int size = coll.size();
        System.out.println("size:"+size);//size:3

        //public Object[] toArray():把集合中的元素，存储到数组中。
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //public void clear():清空集合中所有的元素，但是不删除集合，集合还存在
        coll.clear();
        System.out.println(coll);
    }
}

运行结果：

三、Iterator迭代器

1. Iterator接口介绍

• java.util.Iterator接口：迭代器（对集合进行遍历）
• 两个常用的方法：

• boolean hasNext() 如果仍有元素可以迭代，则返回True
• 判断集合中还有没有下一个元素，有就返回True，没有就返回False
• E next() 返回迭代的下一个元素。
• 取出集合中的下一个元素

• Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
• Collection接口中有一个方法，叫iterator()，这个方法返回的就是迭代器的实现类对象
• Iterator< E> iterator() 返回在此 collection的元素上进行迭代的迭代器

• 迭代器的使用步骤(重点)：

• 使用集合中的方法Iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）
• 使用Iterator接口中的方法hasNext判断还有没有下一个元素
• 使用Iterator接口中的方法next取出集合中的下一个元素

2. 迭代器的代码实现

package day15.demo02;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo02Iterator {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection<String> coll = new ArrayList<>();
        //往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");
        coll.add("艾弗森");

        /*
            1.使用集合中的方法Iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）
            注意：
                Iterator<E>接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
         */
        //多态 接口 实现类对象
        Iterator<String> it = coll.iterator();

        /*
            发现使用迭代器取出集合中元素的代码，是一个重复的过程
            所以我们可以使用循环优化
            不知道集合中有多少元素，使用while循环
            循环结束的条件，hasNext方法返回false
         */
        while (it.hasNext()) {
            String e = it.next();
            System.out.println(e);
        }
        System.out.println("=========================");
        for(Iterator<String> it2 = coll.iterator();it2.hasNext();) {
            String e = it2.next();
            System.out.println(e);
        }

        /*//2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
        boolean b= it.hasNext();
        System.out.println(b);//true
        //3.使用Iterator接口中的方法next取出集合中的下一个元素
        String s = it.next();
        System.out.println(s);//姚明

        b = it.hasNext();
        System.out.println(b);
        s = it.next();
        System.out.println(b);
        b = it.hasNext();
        System.out.println(b);
        s = it.next();
        System.out.println(b);
        b = it.hasNext();
        System.out.println(b);
        s = it.next();
        System.out.println(b);

        b = it.hasNext();
        System.out.println(b);
        s = it.next();
        System.out.println(b);*/
    }
}

运行结果：

3. 迭代器的实现原理

4. 增强for循环

• 增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写。
• 是JDK1.5之后出现的新特性
• Colletion< E >extends Iterable< E >:所有的单列集合都可以使用增强for
• public interface Iterable< T >实现这个接口允许对象成为“foreach”语句的目标。
• 增强for循环：用来遍历集合和数组
• 格式：
  for (集合/数组的数据类型 变量名：集合名/数组名) {
  sout(变量名);
  }

package day15.demo02;

import java.util.ArrayList;

public class Demo02foreach {
    public static void main(String[] args) {
        demo01();
        demo02();
    }

    //使用增强for循环遍历集合
    private static void demo02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        for (String s : list) {
            System.out.println(s);
        }
    }

    //使用增加for循环遍历数组
    private static void demo01() {
        int[] arr = {1,2,3,4,5};
        for (int i :arr) {
            System.out.println(i);
        }
    }
}

运行结果：