day06 集合

Collection接口

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

/*
* java.util.Collection接口,所有单列集合的顶层的接口
* 接口中的方法：所有的子类接口和实现类，都具备
* 接口是抽象的，不能实例化对象，找实现类使用ArrayList
* */
    public class CollectionTest {
        public static void main(String[] args) {
        m05();
    }


    /*
     * Collection接口方法
     *   Object[] toArray()集合中的元素转成数组
     */

    public static void m05(){
        //多态形式创建集合,存储字符串
        Collection<String> col = new ArrayList<String>();
        col.add("i");
        col.add("love");
        col.add("java");
        col.add("love");
        //方法toArray()集合中的元素,转成数组
        Object[] array = col.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }




    /*
     * Collection接口方法
     *   boolean remove(Object obj)移除集合中指定的元素
     *   移除成功,返回true,移除失败返回false
     */

    public static void m04(){
        //多态形式创建集合,存储字符串
        Collection<String> col=new ArrayList<>();
        col.add("i");
        col.add("love");
        col.add("java");
        col.add("love");
        System.out.println(col);
        //调用方法 remove()移除元素love。注意：只移除第一个遇到的，后面如果还有，不移除
        boolean b = col.remove("love");
        System.out.println(b);
        System.out.println(col);
    }



    /*
     * Collection接口方法
     *   boolean isEmpty()判空方法,集合中没有元素,返回true
     *   如果容器中有元素,返回false
     */
    public static void m03(){
    //多态形式创建集合,存储字符串
        Collection<String> col=new ArrayList<>();
        col.add("i");
        col.add("love");
        col.add("java");
        System.out.println(col);
        col.clear();
        //调用方法isEmpty（）
        boolean b = col.isEmpty();
        System.out.println(b);

    }


    /*
     * Collection接口方法
     *   boolean contains(Object obj)判断对象,是否存在于集合中
     *   存在返回true
     */
    public static void m02(){
        //多态形式创建集合,存储字符串
        Collection<String> col=new ArrayList<>();
        col.add("i");
        col.add("love");
        col.add("java");
        System.out.println(col);
        //集合方法contains()判断love元素,是否存在于集合中
        boolean b = col.contains("love");
        System.out.println(b);
    }



 /*
 * Collection接口方法
 *   void clear() 清空集合容器中的所有元素
 */
    public static void m01(){
     //多态形式创建集合，存储字符串   （多态）父类引用=子类对象
        Collection<String> col=new ArrayList<String>();
        col.add("i");
        col.add("love");
        col.add("java");
        System.out.println(col);
        //调用集合方法clear（）,元素没有了，但是集合还在。
        col.clear();
        System.out.println(col);
 }
}

--------------------------------------------

List
ArrayList

import com.itheima.对象数组.Person;

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

/*
*  java.util.ArrayList
 *  实现接口List,具备 有序,索引,重复
 *
 *  ArratList集合，底层数据结构是数组
 *  查询速度快，增减速度慢
 *  数组默认长度10
 *
 *  是线程不安全的集合（不同步）运行速度快
* */
public class ArrayListTest01 {
    public static void main(String[] args) {
        //使用集合ArrayList，存储自定义的对象，遍历
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三",100));
        list.add(new Person("李四",101));
        list.add(new Person("王五",102));
        list.add(new Person("赵六",103));
        //以前的
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("***************");


        //现在的
        Iterator<Person> it = list.iterator();
        while(it.hasNext()){
            Person s = it.next();
            System.out.println(s);
        }


    }
}

源码

import java.util.ArrayList;

/*
 *  ArrayList 源码
 *    Object[] elementData   集合内部的数组
 *
 *    分析构造方法: 无参数
 *    创建ArrayList对象, new ArrayList() 构造方法源码中
 *       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
 *          存储元素数组  =  空数组
 *
 *    添加元素方法: add
 *     存储元素"a"  结局存储在0索引上
 *     存储之前,检测集合中数组的容量
 *
 *     ensureCapacityInternal(1)
 *
 *     calculateCapacity(数组,1)
 *
 *      private static int calculateCapacity(Object[] elementData, 1) {
 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
 return Math.max(10, 1);
 }
 return minCapacity;
 }

 ensureExplicitCapacity(10){
 if(10 - 数组.长度>0){
 grow(10);
 }
 }
 void grow(10){
 int oldCapacity = elementData.length;0
 int newCapacity = oldCapacity + (oldCapacity >> 1);
 新容量 = 老容量+(老容量 /2)
 if(0 -10 < 0)
 新容量 = 10

 elementData = Arrays.copyOf(elementData, 10);
 }
 结论:  new对象 ArrayList,使用无参数的构造方法,数组就空的
 第一次add()添加元素,经过计算,将数组复制的方式,原始数组扩容为10长度
 */
public class ArrayListTest02源码 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList(20);
        int[]arr=new int[3];
        arrayList.add("a");
    }
}

LinkedList

import java.util.LinkedList;

/*
 * Java.util.LinkedList 集合实现接口List
 * 底层数据结构是链表,双向
 * 增删快,查询速度慢
 * 线程不安全的集合,运行速度快
 *
 * 集合: 有序,索引,重复
 *
 * LinkedList自己特有的方法
 *   addFirst() 在链表开头添加元素
 *   addLast()  在链表结尾添加元素
 *
 *   getFirst() 获取链表开头元素
 *   getLast()  获取链表结尾元素
 *
 *   removeFirst() 移除链表开头元素
 *   removeLast() 移除链表结尾元素
 */
public class LinkedListTest01 {
    public static void main(String[] args) {
    m04();
    }



    /*
     *  pop   弹出第一个元素  == removeFirst
     *  push  将元素推入集合  == addFirst
     */
    public static void m04(){
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        linkedList.add("d");
        //pop,将集合中的第一个元素弹出
        String pop = linkedList.pop();
        System.out.println(pop);
        System.out.println(linkedList);

        //push,元素推入集合
        linkedList.push("0");
        System.out.println(linkedList);
    }






    /*
     *   removeFirst() 移除链表开头元素
     *   removeLast() 移除链表结尾元素
     */
    public static void m03(){
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        linkedList.add("d");
        //移除链表开头元素,返回被移除之前的元素
        String first = linkedList.removeFirst();
        //移除链表结尾元素,返回被移除之前的元素
        String last = linkedList.removeLast();
        System.out.println(first);
        System.out.println(last);
        System.out.println(linkedList);
    }




    /*
     *   getFirst() 获取链表开头元素
     *   getLast()  获取链表结尾元素
     */
    public static void m02(){
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        linkedList.add("d");
        //获取链表开头元素
        String first = linkedList.getFirst();
        //获取链表结尾元素
        String last = linkedList.getLast();
        System.out.println(first);
        System.out.println(last);
        System.out.println(linkedList);
    }


    /*
     *   addFirst() 在链表开头添加元素
     *   addLast()  在链表结尾添加元素
     */
    public static void m01(){
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        //链表的结尾添加元素02
        linkedList.addLast("6");

        linkedList.add("c");
        linkedList.add("d");
        System.out.println(linkedList);
        //链表开头添加元素
        linkedList.addFirst("0");
        //链表的结尾添加元素01
        linkedList.addLast("9");
        System.out.println(linkedList);
    }
}
/*
 *   LinkedList:
 *      private static class Node<E> {
 E item;  保存数据
 Node<E> next;  记录下一个元素
 Node<E> prev;  记录上一个元素
 }
 */

List

import java.util.ArrayList;
import java.util.List;

/*
 *  java.util.List接口,继承Collection接口
 *  List集合的特点:
 *    1: 有序的集合
 *      不是 a b c 1 2 3顺序
 *      有序: 集合中,元素存储的顺序和取出顺序一致
 *
 *    2: 集合中的元素带有索引
 *
 *    3: 可以存储重复元素
 *
 *    结论: 有序,索引,重复
 *    凡是List接口的实现类,都具备以上的三个特点
 *
 *
 *    List有两个常用接口：ArrayList，LinkedList
 *
 *   List接口中的方法,带有索引的方法
 *
 *   Collection接口中的方法,没有索引
 *   List接口继承Collection,共性方法无需在演示
 */
public class ListTest {
    public static void main(String[] args) {
    m03();
    }
    /*
     *  set(int index ,Object obj)修改指定索引上的元素
     *  返回被修改之前的元素
     */

    public static void m03(){
        //创建集合对象,使用多态,List接口
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        System.out.println(list);
        //修改2索引上的元素,改为大写E
        String set = list.set(2, "P");
        System.out.println(set);
        System.out.println(list);
    }





    /*
     *  remove(int index)移除指定索引上的元素
     *  但是会返回被删除之前的元素
     */

    public static void m02(){
        //创建集合对象,使用多态,List接口
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        System.out.println(list);
        //移除2索引上的元素
        String remove = list.remove(2);
        System.out.println(remove);
        System.out.println(list);
    }


    /*
     *  add(int index, Object obj)指定索引,在索引上添加元素
     */
    public static void m01(){
        //创建集合对象,使用多态,List接口
        //多态：父类引用=子类对象
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        System.out.println(list);
        //指定索引2,添加字母e
        list.add(2,"e");
        System.out.println(list);
    }
}

--------------------------------------------

对象数组

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }

    public Person() {

    }
    /*public String toString(){
        return name+age;
    }*/
    //用快捷键ctrl+ins,选择toString

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

/*
* 数组：本质是容器，存储数据
* 基本类型数组：数组中存储的数据类型是基本类型
* 引用类型数组：存储引用类型（对象数组）
* String[],Person对象数组,Student对象数组
*
* 数组的弊端：数组是定长的，一旦创建，长度不能改变
*
* jdk1.2版本开始，出现了集合框架
*
*集合数组的特点
*     都是临时容器，存储数据的
*     数组是定长的
*     集合是变长
*
*     数组存储基本类型和引用类型
*     集合不存储基本类型，存储引用类型
*
*
*     数组要是多了，存在数组
*     对象要是多了，存储集合
* * */
public class ArrayTest {
    public static void main(String[] args) {
        //定义数组，存储Person对象
        Person[] persons={new Person("张三",10),new Person("李四",20),new Person("王五",30)};
        System.out.println(persons.length);
        //遍历数组
        for (int i = 0; i < persons.length; i++) {
            //输出数组中的每个元素
            //sout语句默认调用方法toString（）方法
            System.out.println(persons[i]);
        }

    }
}

--------------------------------------------

斗地主案例

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

/*
 *   斗地主案例: 集合练习
 *
 *   1: 准备牌
 *     54个字符串 (54张扑克牌) --> 存在集合
 *     4个花色,每个花色对应13个点数 A-K
 *     1个花色 : 13个点数  花色+点数组合  花+点数
 *     2个花色 : 13个点数
 *     3个花色 : 13个点数
 *     4个花色 : 13个点数
 *     一共组合4轮,每轮组合13次
 *     外循环4次,内循环13次  4*13=52
 *      花色       点数
 *
 *   2:洗牌:
 *     集合中字符串的顺序打乱
 *
 *   3: 发牌:
 *     牌盒集合中的字符串,取出一个,存储在玩家的集合中
 *     定义出4个集合: 三个玩家,底牌
 *     牌盒集合中的索引取出, 0-53  索引%3,获取余数
 *     预先预留三张底牌
 *
 *   4:看牌:
 *     玩家手中集合遍历
 *
 */
public class Poker {
    public static void main(String[] args) {
        //定义集合，存储54个字符串
        ArrayList<String> poker = new ArrayList<>();
        //创建数组，保存4个花色
        String[]color={"♠","♥","♣","♦"};
        //创建数组，保存13个点数
        String[]numbers={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        //循环遍历数组，外循环是花色，内循环是点数
        for (int i = 0; i < color.length; i++) {
            for (int i1 = 0; i1 < numbers.length; i1++) {
                //花色+点数组合，存储在集合中
                poker.add(color[i]+numbers[i1]);
            }
        }
        //存储王牌
        poker.add("大王");
        poker.add("小王");
       // System.out.println(poker);

        //打乱集合中的元素顺序，Collections集合的工具类，静态方法
        Collections.shuffle(poker);//对List集合中的元素随机排序

        //创建玩家集合，底牌集合
        ArrayList<String> play01 = new ArrayList<>();
        ArrayList<String> play02 = new ArrayList<>();
        ArrayList<String> play03 = new ArrayList<>();
        ArrayList<String> bottom = new ArrayList<>();

        //牌盒集合中的字符串，取出一个，存储在玩家的集合中
        //遍历集合poker集合，遍历的索引进行模计算  %3  结果只能是0  1  2
        for (int i = 0; i < poker.size(); i++) {
            //先拿3张出来，发底牌
            if(i<3){
                bottom.add(poker.get(i));
            }
            //索引 i%3计算
            else if (i%3==0){
                //索引上的牌，发给玩家1
                play01.add(poker.get(i));

            }else if(i%3==1){
                //索引上的牌，发给玩家2
                play02.add(poker.get(i));
            } else if (i%3==2) {
                //索引上的牌，发给玩家3
                play03.add(poker.get(i));
            }
        }

        //看牌，调用方法
        look(play01);
        look(play02);
        look(play03);
        look(bottom);
    }

    //创建方法，专门遍历集合
    public static void look(ArrayList<String> arrayList){
        Iterator<String> iterator = arrayList.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next()+"");
    }
        System.out.println();
    }

}

--------------------------------------------

迭代器

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

/*
 * 迭代器（Iterator）：
 *    迭代就是遍历，是所有的Collection集合通用遍历方式
 *
 *    java.util.Iterator接口：对集合遍历的迭代器
 *    接口中的抽象方法：
 *       1：boolean hasNext() 判断集合中是否有下一个元素，如果有返回true
 *       2：Object next（）  取出集合下一个元素
 *       3：remove（）   移除元素，迭代到哪一个，移除哪一个
 *
 *    接口实现类：
 *       接口实现类，不能自己创建，通过方法来获取
 *       方法的返回值就是接口类型
 *     Collection接口定义方法 :  Iterator iterator() 获取迭代器接口实现类对象
 *     ArrayList实现接口Collection,必然重写方法iterator
 * */
public class IteratorTest01 {
    public static void main(String[] args) {
        Collection<String> col=new ArrayList<String>();
        col.add("i");
        col.add("love");
        col.add("java");
        col.add("Ok");
        /*
         * 使用迭代器,对集合进行遍历
         * 步骤:
         *  1: 使用集合的方法 iterator()获取迭代器接口Iterator实现类对象
         *  2: 迭代器接口实现类对象调用方法 hasNext()
         *  3: 迭代器接口实现类对象调用方法next()
         */
        Iterator<String> it = col.iterator();
        //System.out.println(it);
        //循环判断
        //循环中,判断集合中是否有下一个元素
        while(it.hasNext()){
            //取出集合中的元素
            String s = it.next();
            System.out.println(s);
        }


        System.out.println("**************************");
        for (Iterator<String> itFor=col.iterator();itFor.hasNext();){
            System.out.println(itFor.next());
        }
    }
}
/*
 boolean b = it.hasNext();
 System.out.println(b);

 String s = it.next();
 System.out.println(s);

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

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

异常问题

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

/*
 *  迭代器并发修改异常:
 *    怎么引发的,如何避免
 *    ConcurrentModificationException 并发修改异常
 *    出现原因: 在迭代器遍历的过程中, 使用集合的方法改变了集合的长度
 *
 *
 *
 *    这是一个异常现象，我们要避免其发生
 */
public class IteratorTest02异常问题 {
    public static void main(String[] args) {
        Collection<String> col=new ArrayList<String>();
        col.add("i");
        col.add("love");
        col.add("java");
        col.add("Ok");
        //迭代器遍历集合,遍历的过程中,判断集合中是否有love元素
        //如果有,向集合中添加元素 LOVE
        Iterator<String> it = col.iterator();
        while(it.hasNext()){
            String s = it.next();
            //判断,遍历到的元素,是不是love
            if("love".equals(s)){
                //向集合中添加元素 LOVE
                col.add("LOVE");
            }
        }
        System.out.println(col);
    }
}

--------------------------------------------