List的子类

ArrayList

功能与List一样

Vector

特有功能

  1：添加功能
        public void addElement(Object obj)      --  add()
  2：获取功能
        public Object elementAt(int index)      --  get()
        public Enumeration elements()           --  Iterator iterator()
                boolean hasMoreElements()               hasNext()
                Object nextElement()                    next()

  JDK升级的原因：
        A:安全
        B:效率
        C:简化书写

package cn.itcast_02;

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Vector v = new Vector();

        // 添加功能
        v.addElement("hello");
        v.addElement("world");
        v.addElement("java");

        // 遍历
        for (int x = 0; x < v.size(); x++) {
            String s = (String) v.elementAt(x);
            System.out.println(s);
        }

        System.out.println("------------------");

        Enumeration en = v.elements(); // 返回的是实现类的对象
        while (en.hasMoreElements()) {
            String s = (String) en.nextElement();
            System.out.println(s);
        }
    }
}

LinkedList

特有功能

        A:添加功能
            public void addFirst(Object e)
            public void addLast(Object e)
        B:获取功能
            public Object getFirst()
            public Obejct getLast()
        C:删除功能
            public Object removeFirst()
            public Object removeLast()

package cn.itcast_03;

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedList link = new LinkedList();

        // 添加元素
        link.add("hello");
        link.add("world");
        link.add("java");

        // public void addFirst(Object e)
        // link.addFirst("javaee");
        // public void addLast(Object e)
        // link.addLast("android");

        // public Object getFirst()
        // System.out.println("getFirst:" + link.getFirst());
        // public Obejct getLast()
        // System.out.println("getLast:" + link.getLast());

        // public Object removeFirst()
        System.out.println("removeFirst:" + link.removeFirst());
        // public Object removeLast()
        System.out.println("removeLast:" + link.removeLast());

        // 输出对象名
        System.out.println("link:" + link);
    }
}

练习题

练习题1

  ArrayList去除集合中字符串的重复值(字符串的内容相同)

  分析：
        A:创建集合对象
        B:添加多个字符串元素(包含内容相同的)
        C:创建新集合
        D:遍历旧集合,获取得到每一个元素
        E:拿这个元素到新集合去找，看有没有
            有：不搭理它
            没有：就添加到新集合
        F:遍历新集合

package cn.itcast_04;

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

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 添加多个字符串元素(包含内容相同的)
        array.add("hello");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("java");
        array.add("world");

        // 创建新集合
        ArrayList newArray = new ArrayList();

        // 遍历旧集合,获取得到每一个元素
        Iterator it = array.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();

            // 拿这个元素到新集合去找，看有没有
            if (!newArray.contains(s)) {
                newArray.add(s);
            }
        }

        // 遍历新集合
        for (int x = 0; x < newArray.size(); x++) {
            String s = (String) newArray.get(x);
            System.out.println(s);
        }
    }
}

练习题2

  需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
  要求：不能创建新的集合，就在以前的集合上做。

package cn.itcast_04;

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

public class ArrayListDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 添加多个字符串元素(包含内容相同的)
        array.add("hello");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("java");
        array.add("world");

        // 由选择排序思想引入，我们就可以通过这种思想做这个题目
        // 拿0索引的依次和后面的比较，有就把后的干掉
        // 同理，拿1索引...
        for (int x = 0; x < array.size() - 1; x++) {
            for (int y = x + 1; y < array.size(); y++) {
                if (array.get(x).equals(array.get(y))) {
                    array.remove(y);
                    y--;
                }
            }
        }

        // 遍历集合
        Iterator it = array.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }
    }
}

练习题3

  需求：去除集合中自定义对象的重复值(对象的成员变量值都相同)

  我们按照和字符串一样的操作，发现出问题了。
  为什么呢?
        我们必须思考哪里会出问题?
        通过简单的分析，我们知道问题出现在了判断上。
        而这个判断功能是集合自己提供的，所以我们如果想很清楚的知道它是如何判断的，就应该去看源码。
  contains()方法的底层依赖的是equals()方法。
  而我们的学生类中没有equals()方法，这个时候，默认使用的是它父亲Object的equals()方法
  Object()的equals()默认比较的是地址值，所以，它们进去了。因为new的东西，地址值都不同。
  按照我们自己的需求，比较成员变量的值，重写equals()即可。
  自动生成即可。

package cn.itcast_04;

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

public class ArrayListDemo3 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 创建学生对象
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("林志玲", 40);
        Student s3 = new Student("凤姐", 35);
        Student s4 = new Student("芙蓉姐姐", 18);
        Student s5 = new Student("翠花", 16);
        Student s6 = new Student("林青霞", 27);
        Student s7 = new Student("林青霞", 18);

        // 添加元素
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        array.add(s5);
        array.add(s6);
        array.add(s7);

        // 创建新集合
        ArrayList newArray = new ArrayList();

        // 遍历旧集合,获取得到每一个元素
        Iterator it = array.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();

            // 拿这个元素到新集合去找，看有没有
            if (!newArray.contains(s)) {
                newArray.add(s);
            }
        }

        // 遍历新集合
        for (int x = 0; x < newArray.size(); x++) {
            Student s = (Student) newArray.get(x);
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

练习题4

 请用LinkedList模拟栈数据结构的集合，并测试
 题目的意思是：
        你自己的定义一个集合类，在这个集合类内部可以使用LinkedList模拟。

package cn.itcast_05;

import java.util.LinkedList;

/**
 * 自定义的栈集合
 * 
 * @author 风清扬
 * @version V1.0
 */
public class MyStack {
    private LinkedList link;

    public MyStack() {
        link = new LinkedList();
    }

    public void add(Object obj) {
        link.addFirst(obj);
    }

    public Object get() {
        // return link.getFirst();
        return link.removeFirst();
    }

    public boolean isEmpty() {
        return link.isEmpty();
    }
}

package cn.itcast_05;

/*
 * MyStack的测试
 */
public class MyStackDemo {
    public static void main(String[] args) {
        // 创建集合对象
        MyStack ms = new MyStack();

        // 添加元素
        ms.add("hello");
        ms.add("world");
        ms.add("java");

        // System.out.println(ms.get());
        // System.out.println(ms.get());
        // System.out.println(ms.get());
        // NoSuchElementException
        // System.out.println(ms.get());

        while(!ms.isEmpty()){
            System.out.println(ms.get());
        }
    }
}

练习题5

  集合的嵌套遍历
  需求：
        我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
        但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。
        而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢?
        就是这个样子的：ArrayList<ArrayList<Student>>

package cn.itcast_01;

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建大集合
        ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>();

        // 创建第一个班级的学生集合
        ArrayList<Student> firstArrayList = new ArrayList<Student>();
        // 创建学生
        Student s1 = new Student("唐僧", 30);
        Student s2 = new Student("孙悟空", 29);
        Student s3 = new Student("猪八戒", 28);
        Student s4 = new Student("沙僧", 27);
        Student s5 = new Student("白龙马", 26);
        // 学生进班
        firstArrayList.add(s1);
        firstArrayList.add(s2);
        firstArrayList.add(s3);
        firstArrayList.add(s4);
        firstArrayList.add(s5);
        // 把第一个班级存储到学生系统中
        bigArrayList.add(firstArrayList);

        // 创建第二个班级的学生集合
        ArrayList<Student> secondArrayList = new ArrayList<Student>();
        // 创建学生
        Student s11 = new Student("诸葛亮", 30);
        Student s22 = new Student("司马懿", 28);
        Student s33 = new Student("周瑜", 26);
        // 学生进班
        secondArrayList.add(s11);
        secondArrayList.add(s22);
        secondArrayList.add(s33);
        // 把第二个班级存储到学生系统中
        bigArrayList.add(secondArrayList);

        // 创建第三个班级的学生集合
        ArrayList<Student> thirdArrayList = new ArrayList<Student>();
        // 创建学生
        Student s111 = new Student("宋江", 40);
        Student s222 = new Student("吴用", 35);
        Student s333 = new Student("高俅", 30);
        Student s444 = new Student("李师师", 22);
        // 学生进班
        thirdArrayList.add(s111);
        thirdArrayList.add(s222);
        thirdArrayList.add(s333);
        thirdArrayList.add(s444);
        // 把第三个班级存储到学生系统中
        bigArrayList.add(thirdArrayList);

        // 遍历集合
        for (ArrayList<Student> array : bigArrayList) {
            for (Student s : array) {
                System.out.println(s.getName() + "---" + s.getAge());
            }
        }
    }
}

练习题6

  获取10个1-20之间的随机数，要求不能重复

  用数组实现，但是数组的长度是固定的，长度不好确定。
  所以我们使用集合实现。

  分析：
        A:创建产生随机数的对象
        B:创建一个存储随机数的集合。
        C:定义一个统计变量。从0开始。
        D:判断统计遍历是否小于10
            是:先产生一个随机数，判断该随机数在集合中是否存在。
                    如果不存在:就添加，统计变量++。
                    如果存在:就不搭理它。
            否：不搭理它
        E:遍历集合

package cn.itcast_02;

import java.util.ArrayList;
import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        // 创建产生随机数的对象
        Random r = new Random();

        // 创建一个存储随机数的集合。
        ArrayList<Integer> array = new ArrayList<Integer>();

        // 定义一个统计变量。从0开始。
        int count = 0;

        // 判断统计遍历是否小于10
        while (count < 10) {
            //先产生一个随机数
            int number = r.nextInt(20) + 1;

            //判断该随机数在集合中是否存在。
            if(!array.contains(number)){
                //如果不存在:就添加，统计变量++。
                array.add(number);
                count++;
            }
        }

        //遍历集合
        for(Integer i : array){
            System.out.println(i);
        }
    }
}

练习题7

  键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值

  分析：
        A:创建键盘录入数据对象
        B:键盘录入多个数据,我们不知道多少个，所以用集合存储
        C:以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
        D:把集合转成数组
        E:对数组排序
        F:获取该数组中的最大索引的值

package cn.itcast_03;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建键盘录入数据对象
        Scanner sc = new Scanner(System.in);

        // 键盘录入多个数据,我们不知道多少个，所以用集合存储
        ArrayList<Integer> array = new ArrayList<Integer>();

        // 以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
        while (true) {
            System.out.println("请输入数据：");
            int number = sc.nextInt();
            if (number != 0) {
                array.add(number);
            } else {
                break;
            }
        }

        // 把集合转成数组
        // public <T> T[] toArray(T[] a)
        Integer[] i = new Integer[array.size()];
        // Integer[] ii = array.toArray(i);
        array.toArray(i);
        // System.out.println(i);
        // System.out.println(ii);

        // 对数组排序
        // public static void sort(Object[] a)
        Arrays.sort(i);

        // 获取该数组中的最大索引的值
        System.out.println("数组是：" + arrayToString(i) + "最大值是:"
                + i[i.length - 1]);
    }

    public static String arrayToString(Integer[] i) {
        StringBuilder sb = new StringBuilder();

        sb.append("[");
        for (int x = 0; x < i.length; x++) {
            if (x == i.length - 1) {
                sb.append(i[x]);
            } else {
                sb.append(i[x]).append(", ");
            }
        }
        sb.append("]");

        return sb.toString();
    }
}