Java~List-son

/* 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 List; 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);         }     } } /* hello world java ------------------ hello world java  过程结束了，退出代码0 */

/* * 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 集合练习;  import jdk.jshell.spi.ExecutionControl;  import java.util.Arrays; /*模拟双向链表*/ class Node{     public Object item;     public Node next; //后一个结点     public Node pre; //前一个结点     public Node(Object name){         this.item=name;     }      @Override     public String toString() {         return "Node{"                   "item="   item                   '}';     } } public class ListLinked01 {     public static void main(String[] args) {         Node jack=new Node("jack");         Node tom=new Node("Tom");         Node hsp=new Node("老韩");         //连接三个结点，形成双向链表         jack.next=tom;         tom.next=hsp;         hsp.pre=tom;         tom.pre=jack;         Node first=jack;         Node last=hsp;         /*打印*/         System.out.println("遍历从头到尾");         while(true){             if(first==null)                  break;             System.out.println(first);             first=first.next;         }         System.out.println("从头到尾遍历");         while(true){             if(last==null)                 break;             System.out.println(last);            last=last.pre;         }         //插入对象，在tom和老韩之间         Node smith=new Node("Smith");         smith.next=hsp;         tom.next=smith;          hsp.pre=smith;          smith.pre=tom;           first=jack;          last=hsp;         System.out.println("遍历从头到尾");         while(true){             if(first==null)                 break;             System.out.println(first);             first=first.next;         }     } } 

package List; 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());         System.out.println("link:"   link);         // public Object removeFirst()         System.out.println("removeFirst:"   link.removeFirst());         // public Object removeLast()         System.out.println("removeLast:"   link.removeLast());          // 输出对象名         System.out.println("link:"   link);     } } /* getFirst:javaee getLast:android link:[javaee, hello, world, java, android] removeFirst:javaee removeLast:andrid
link:[hello, world, java]
进程已结束,退出代码0
*/

package List;
import java.util.Iterator;
import java.util.LinkedList;

/*
 *请用LinkedList模拟栈数据结构的集合，并测试
 *题目的意思是：
 *		你自己的定义一个集合类，在这个集合类内部可以使用LinkedList模拟。
 */
public class LinkedListDemo1 {
    public static void main(String[] args) {
        // A: LinkedList的特有添加功能addFirst()
        // B:栈的特点先进后出
        // 创建集合对象
         LinkedList link = new LinkedList();

        // // 添加元素
          link.addFirst("hello");
          link.addFirst("world");
         link.addFirst("java");
        //
        // // 遍历
         Iterator it = link.iterator();
          while (it.hasNext()) {
          String s = (String) it.next();
          System.out.println(s);
          }
/*
java
world
hello
进程已结束,退出代码0

 */
        //为什么呢?
    }
}

/**
 * 自定义的栈集合
 *
 */

package List;
import java.util.LinkedList;


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 List;
/*
 * 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());
        }
    }
}

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

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

// 由选择排序思想引入，我们就可以通过这种思想做这个题目         // 拿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--;                 }             }         }

package List;
        import java.util.ArrayList;
        import java.util.Iterator;
/*
 * ArrayList去除集合中字符串的重复值(字符串的内容相同)
 *
 * 分析：
 * 		A:创建集合对象
 * 		B:添加多个字符串元素(包含内容相同的)
 * 		C:创建新集合
 * 		D:遍历旧集合,获取得到每一个元素
 * 		E:拿这个元素到新集合去找，看有没有
 * 			有：不搭理它
 * 			没有：就添加到新集合
 * 		F:遍历新集合
 */
public class ArrayListDemo1 {
    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);
        }
    }
}
/*
hello
world
java
*/

练习题：

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

package List;
import java.util.ArrayList;
public class ArrayListDemoTest {
    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());
            }
        }
    }
}
/*
唐僧---30
孙悟空---29
猪八戒---28
沙僧---27
白龙马---26
诸葛亮---30
司马懿---28
周瑜---26
宋江---40
吴用---35
高俅---30
李师师---22
进程已结束,退出代码0

 */

/*
 * 获取10个1-20之间的随机数，要求不能重复
 *
 * 用数组实现，但是数组的长度是固定的，长度不好确定。
 * 所以我们使用集合实现。
 *
 * 分析：
 *        A:创建产生随机数的对象
 *        B:创建一个存储随机数的集合。
 *        C:定义一个统计变量。从0开始。
 *        D:判断统计遍历是否小于10
 *           是:先产生一个随机数，判断该随机数在集合中是否存在。
 *                 如果不存在:就添加，统计变量++。
 *                 如果存在:就不搭理它。
 *           否：不搭理它
 *        E:遍历集合
 */

重点：JAVA中特定区间产生随机数

int randNumber=rand.nextInt(Max-Min+1)+Min

//randNumber将被赋值为一个Min和Max范围内的随机数。

package List;
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);
        }
    }
}

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

package List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class ArrayListDemo4 {
    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);

         // System.out.println(i);//[Ljava.lang.Integer;@9807454
          //System.out.println(ii);//[Ljava.lang.Integer;@9807454

		//array.toArray(i);


        // 对数组排序
        // 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();
    }
}