java学习day14——StringBulider、集合、Iterator迭代器、泛型

StringBuilder类

String类：
字符串常量，创建后不可更改，字符串的底层是一个被final修饰的数组
private final byte[] value;
StringBuilder类：
字符串缓冲区，可以提高字符串的操作效率（看成一个长度可以变化的字符串）
底层也是一个数组，但是没有被final修饰，可以改变长度
byte[] value = new byte[16];
StringBuilder在内存中始终是一个数组，占用的空间少，效率高，如果超出了StringBuilder的容量，会自动的扩容
StringBuilder类的构造方法及常用方法

public class Demo01StringBuilder {
    public static void main(String[] args) {
        //空参构造方法
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+bu1);
        //带字符串的构造方法
        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:"+bu2);
        //StringBuilder的常用方法
        //append方法返回的是this，即调用方法的对象bu1  this==bu1
        StringBuilder bu3 = bu1.append("efg");//把部的地址赋值给了bu3
        System.out.println(bu1);
        System.out.println(bu3);
        System.out.println(bu1==bu3);//地址相同

        //使用append方法无需接收返回值,可链式编程
        bu1.append("hij").append(1).append(true).append(5.2).append('中');
        System.out.println(bu1);

        //toString方法:StringBuilder->String
        String s = bu2.toString();
        System.out.println(s);
    }
}

集合Collection

集合框架

集合和数组的区别

1. 存储的数据类型
   数组可以存储基本类型，也可以存储引用类型
   集合只能存储引用类型
2. 存储的内容
   数组只能存储一种类型的数据
   集合可以存储不同类型（Object），但一般存储的是同一种类型
3. 长度
   数组不可变，集合可变

Colletion常用功能

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

/*
java.util.Collection接口：
是所有单列集合的最顶层的接口，里面定义了所有单列集合共性的方法
任意的单列集合都可以使用Collection接口中的方法
 */
public class Demo01Collection {
    public static void main(String[] args) {
        // 创建集合对象，可以使用多态
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);//重写了toString方法 []
        // public boolean add(E e):把给定对象添加到当前集合中
        coll.add("abc");
        coll.add("efg");
        System.out.println(coll);//[abc]

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

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

        // public boolean remove(E e):把给定对象再当前集合中删除,删除成果返回true
        coll.remove("abc");
        System.out.println(coll);//[efg]

        // public boolean contains(E e)：判断当前集合中是否包含给定的对象
        System.out.println(coll.contains("efg"));//true

        // public void clear()：情况集合当中所有的元素
        coll.clear();
        System.out.println(coll);//[]

        // public boolean isEmpty()：判断当前集合是否为空
        System.out.println(coll.isEmpty()); //true
    }
}

Iterator迭代器

Iterator迭代器的使用方法

/*
java.util.Iterator接口：迭代器（对集合进行遍历）
有两个常用方法
    boolean hasNext() 如果仍有元素可以迭代，则返回 true。
    E next() 返回迭代的下一个元素。
Iterator迭代器是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
Collection接口中有一个方法，叫iterator(),这个方法返回的就是迭代器的实现类对象
    Iterator<E> iterator() 返回在此collection的元素上进行迭代的迭代器
迭代器的使用步骤:
    1. 使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收（多态）
    2. 使用Iterator接口中的方法hasNext判断还有没有下一个元素
    3. 使用Iterator接口中的方法next取出集合中的下一个元素
 */
public class Demo02Iterator {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("abc");
        coll.add("def");
        coll.add("ghi");
        // Iterator<E>接口也是有泛型的，泛型跟集合保持一致
        Iterator<String > it = coll.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

增强for

import java.util.ArrayList;

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

泛型

泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型
泛型也可以看成是一个变量，用来接收数据类型
E e：Element 元素
T t：Type 类型
ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以使用泛型，创建对象的时候会确定泛型的类型，会把数据类型作为参数传递，赋值给泛型E

使用泛型的好处

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

public class Demo01Generic {
    public static void main(String[] args) {
//        show01();
        show02();
    }
/*
    创建集合对象，使用泛型
    好处：
        1.避免了类型转换的麻烦，存储的是什么类型，去除的就是什么类型
        2.把运行期异常（代码运行之后会抛出的异常），提升到了编译器(写代码的时候会报错)
    弊端：泛型是什么类型，就只能存储什么类型的工具
 */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
//        list.add(1);//编译的时候就直接报错
    }

    /*
    创建集合对象，不使用泛型
    好处：集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
    弊端：不安全，会引发异常
     */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);

        Iterator it = list.iterator();
        while(it.hasNext()){
            // 取出元素也是object类型
            Object obj = it.next();
            System.out.println(obj);

            // 想要使用String类特有的方法length获取字符串的长度
            //需要向下转型
            String s = (String)obj;
            System.out.println(s.length()); //抛出ClassCastException异常
        }
    }
}

定义和使用含有泛型的类

定义含有泛型的类

/*
定义一个含有泛型的类，模拟ArrayList集合
泛型是一个未知的数据类型，当我们不确定什么数据类型的时候，可以用泛型
泛型可以接收任意的数据类型，可以使用Integer,String,Student,...
创建对象的时候确定泛型的数据类型
 */
public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

使用含有泛型的类

public class Demo02Generic {
    public static void main(String[] args) {
        // 不写泛型默认为Object类型
        GenericClass gc = new GenericClass();
        gc.setName("只能是字符串");
        Object obj = gc.getName();

        //创建GenericClass对象，泛型用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);
        Integer name = gc2.getName();
        System.out.println(name);
    }
}

定义和使用含有泛型的方法

/*
定义含有泛型的方法：泛型定义在方法的修饰符和返回值之间
格式：
    修饰符<泛型> 返回值类型 方法名（参数列表（使用泛型））{
        方法体；
    }
含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型
 */
public class GenericMethod {
    // 定义一个含有泛型的方法
    public <M> void method01(M m){
        System.out.println(m);
    }
    //定义一个含有泛型的静态方法
    public static <S> void method02(S s){
        System.out.println(s);
    }
}

/*
测试含有泛型的方法
 */
public class Demo03GenericMethod {
    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();
        gm.method01(10);
        gm.method01("abc");
        gm.method01(true);
        gm.method01(8.8);

        gm.method02("静态方法，不建议创建对象使用");
        GenericMethod.method02("静态方法");
    }
}

泛型通配符

不知道使用什么类型接收时用<?>

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

public class Demo05Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("b");

        printArray(list1);
        printArray(list2);
    }
    public static void printArray(ArrayList<?> list){
        Iterator<?> it = list.iterator();
        while(it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }
    }
}

泛型的上限限定和下限限定

斗地主案例

需求分析

代码

import java.util.ArrayList;
import java.util.Collections;

public class DouDiZhu {
    public static void main(String[] args) {
        // 定义一个存储54张牌的ArrayList集合
        ArrayList<String> poker = new ArrayList<>();
        // 定义两个数组，一个数组存储牌的花色，另一个存储序号
        String[] colors = {"♠","♥","♣","♦"};
        String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        // 先把大王小王存储到扑克集合中
        poker.add("大王");
        poker.add("小王");
        // 循环嵌套遍历两个数组，组装52张牌
        for(String number:numbers){
            for(String color :colors){
                // 把组装好的牌存到poker中
                poker.add(color+number);
            }
        }
        System.out.println(poker);
        // 洗牌，使用collections中的工具类
        //static void shuffle(List<?> list)  使用默认随机源对指定列表进行置换。
        Collections.shuffle(poker);
        // 发牌
        // 定义四个集合，存储玩家的牌和底牌
        ArrayList<String> player01 = new ArrayList<>();
        ArrayList<String> player02 = new ArrayList<>();
        ArrayList<String> player03 = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();
        // 遍历poker集合
        for (int i = 0; i < poker.size(); i++) {
            String p = poker.get(i);
            if(i>=51){
                dipai.add(p);
            }else if(i%3 == 0){
                player01.add(p);
            }else if(i%3 == 1){
                player02.add(p);
            }else if(i%3 == 2){
                player03.add(p);
            }
        }
        // 看牌
        System.out.println("刘德华："+player01);
        System.out.println("周润发："+player02);
        System.out.println("周星驰："+player03);
        System.out.println("底牌："+dipai);
    }
}

结果