集合

package yLinked;

/*
 * 使用java语言模拟单向链表
 */
public class Linked {

    //节点
    //数据类型
    Entry entry;
        
    //构造方法
    Linked(){
        //只有一个头节点
        entry = new Entry(null, null);
    }
    
    //静态内部类
    static class Entry{
        
        //数据类型
        Object date;
        Entry next;
        
        //构造方法
        Entry(Object data, Entry next){
            this.date = data;
            this.next = next;
        }
    }
}

package yLinked;

/*
 * boolean add(Object element); 向集合添加元素
 * void clear(); 清空集合
 * boolean isEmpty(); 判断集合中是否有元素
 * int size(); 获取集合中元素的个数
 * Object[] toArray(); 将集合转换成数组
 * 
 * Iterator iterator(); 获取集合所依赖的迭代器对象
 * boolean contains(Object o); 判断集合中是否包含某个元素
 * boolean remove(Object o); 删除集合中某个元素
 */
import java.util.*;

public class CollectionTest01 {

    public static void main(String[] args) {

        //1.创建集合
        Collection c = new ArrayList(); //多态
        
        //2.添加元素
        c.add(1); //JDK5.0之后，自动装箱
        c.add(new Integer(100));
        
        Object o = new Object();
        c.add(o); //Collection集合只能单个存储元素
        
        Customer cus = new Customer("JACK", 20);
        c.add(cus);
        
        //3.获取元素的个数
        System.out.println(c.size()); //4
        System.out.println(c.isEmpty()); //false
        
        //4.将集合转换成Object类型的数组
        Object[] objs = c.toArray();
        for(int i = 0; i < objs.length; i++){
            System.out.println(objs[i]);
        }
        
        //5.清空
        c.clear();
        System.out.println(c.size()); //0
        System.out.println(c.isEmpty()); //true
    }

}

class Customer{
    String name;
    int age;
    
    Customer(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    //重写Object中的toString
    public String toString(){
        return "Customer[name="+name+", age="+age+"]";
    }
}

package yLinked;
/*
 * Iterator iterator(); 获取集合所依赖的迭代器对象
 * 通过迭代器中方法完成集合的迭代(遍历)
 * 
 * 注意：这种方法是所有集合通用的遍历方式
 */
import java.util.*;

public class CollectionTest02 {

    public static void main(String[] args) {

        //创建集合对象
        Collection c = new LinkedList();
        //Collection c = new ArrayList();
        
        //添加元素
        c.add(100); //自动装箱
        c.add(3.14); //自动装箱
        c.add(false); //自动装箱
        
        //迭代，遍历
        //1.获取迭代器对象
        Iterator it = c.iterator(); //迭代器是面向接口编程
                                    //it是引用，保存了内存地址，指向堆中的"迭代器对象"
        
        //java.util.LinkedList$ListItr 类是LinkeList集合所依赖的迭代器
        //java.util.AbstractList$Itr 类是ArrayList集合所依赖的迭代器
        System.out.println(it); //java.util.LinkedList$ListItr@459189e1
                                //java.util.AbstractList$Itr@152b6651
        
        //2.开始调用方法，完成遍历，迭代
        //while循环
        while(it.hasNext()){
            Object element = it.next();
            System.out.println(element);
        }
        
        /*
         * boolean b = it.hasNext(); 判断是否有更多的元素，如果有返回true
         * Object o = it.next(); 将迭代器向下移动一位，并且取出指向的元素
         * 
         * 原则：调用it.next()方法之前必须调用it.hasNext();
         */        
        
        //for循环
        /*
        for(Iterator it = c.iterator(); it.hasNext();){
            Object o = it.next();
            System.out.println(o);
        }
        */
    }

}

package yLinked;

/*
 * boolean contains(Object o); 判断集合中是否包含某个元素
 * boolean remove(Object o); 删除集合中某个元素
 * 
 * 存储在集合中的元素应该去重写equals方法
 */
import java.util.*;

public class CollectionTest03 {

    public static void main(String[] args) {

        //创建集合
        Collection c = new ArrayList();
        
        //创建Integer类型的对象
        Integer i1 = new Integer(10);
        
        //添加元素
        c.add(i1);
        
        //判断集合中是否包含i1
        System.out.println(c.contains(i1)); //true
        
        //创建Integer类型的对象
        Integer i2 = new Integer(10);
        
        //contains方法底层调用的是equals方法，如果equals返回true，就是包含
        System.out.println(c.contains(i2)); //true
        
        
        Manager m1 = new Manager(100, "JACK");
        c.add(m1);
        
        System.out.println(c.contains(m1)); //true
        
        Manager m2 = new Manager(100, "JACK");
        
        //重写equals方法之前
        //System.out.println(c.contains(m2)); //false
        
        //重写equals方法之后，比较内容
        System.out.println(c.contains(m2)); //true
    }

}

class Manager{
    
    int no;
    String name;
    
    Manager(int no, String name){
        this.no = no;
        this.name = name;
    }
    
    //为了让他不要比较内存地址
    //重写equal方法
    //需求规定：如果编号和姓名都相同则表示同一个Manager
    public boolean equals(Object o){
        
        if(this == o) return true;
        if(o instanceof Manager){
            Manager m = (Manager) o;
            if(m.no == this.no && m.name.equals(this.name)){
                return true;
            }
        }
        
        return true;
    }
}

package yLinked;

/*
 * remove和contains方法都需要集合中的元素重写equals方法
 * 因为Object中equals方法比较的是内存地址，在现实的业务逻辑中
 * 不能比较内存地址，应该比较内容
 */
import java.util.*;

public class CollectionTest04 {

    public static void main(String[] args) {
        
        //创建集合对象
        Collection c = new ArrayList();
        
        //创建Integer类型的对象
        Integer i1 = new Integer(10);
        
        //添加元素
        c.add(i1);
        
        //删除元素
        Integer i2 = new Integer(10);
        c.remove(i2);
        
        //i1==i2，所以就删了
        System.out.println(c.size()); //0
        
        Manager m1 = new Manager(100, "SMITH");
        c.add(m1);
        
        Manager m2 = new Manager(100, "SMITH");
        c.remove(m2);
        
        //前面已经重写了，所以是0
        System.out.println(c.size()); //0
    }

}

package yLinked;

/*
 * 深入remove方法
 *         1.选代器的remove方法
 *         2.集合自身带的remove方法
 */
import java.util.*;

public class CollectionTest05 {

    public static void main(String[] args) {

        Collection c = new ArrayList();
        
        c.add(1);
        c.add(2);
        c.add(3);
        
        //遍历
        Iterator it = c.iterator();
        
        while(it.hasNext()){
            
            //推荐用迭代器删除
            Object element = it.next();
            //删除
            it.remove(); //通过迭代器删除
            
            //会报错
            //因为利用集合，删除了第一个就要对迭代器进行更新，会报错
            /*
            //使用集合自身所带的remove方法
            Object element = it.next();
            //删除
            c.remove(element);
            */
        }
        
        System.out.println(c.size()); //0
    }

}

package yLinked;

import java.util.*;;

/*
 * List集合存储元素特点：
 *         1.有序（List集合中存储有下标）：存进去是这样的顺序，取出来还是按照这个顺序取出
 *         2.可重复
 */
public class ListTest01 {

    public static void main(String[] args) {

        //创建一个List集合
        List l = new ArrayList();
        
        //添加
        l.add(100);
        l.add(99);
        l.add(23);
        l.add(250);
        l.add(250);
        
        //遍历
        Iterator it = l.iterator();
        while(it.hasNext()){
            //方法一
            /*
            Object o = it.next();
            System.out.println(o);
            */
            
            //方法二
            System.out.println(it.next()); //100 99 23 250 250
        }
    }

}

package yLinked;

/*
 * 深入List集合
 * 
 * ArrayList集合底层是数组，数组是有下标的
 * 所以ArrayList集合有很多自己的特性
 * 
 * ArrayList集合底层默认初始化容量是10，扩大之后的容量是原容量的1.5倍
 * Vector集合底层默认初始化容量也是10，扩大之后的容量是原容量的2倍
 * 
 * 优化ArrayList和Vector
 *         尽量减少扩容操作，因为扩容需要数组拷贝。数组拷贝很耗内存
 *         一般推荐在创建集合的时候指定初始化容量
 */
import java.util.*;

public class ListTest02 {

    public static void main(String[] args) {

        //创建List集合
        List l = new ArrayList(); //括号里面输入容量
        //List l = new LinkList();
        //改成这个底层数据照样可以运行，面向抽象编程的好处
        
        //添加元素
        l.add(123);
        l.add(321);
        l.add(69);
        
        //在下标为1的位置添加555
        l.add(1, 555);
        
        //取得第一个元素
        System.out.println(l.get(0));
        
        System.out.println("========");
        
        //遍历(List集合特有的遍历方式)
        for(int i = 0; i < l.size(); i++){
            Object element = l.get(i);
            System.out.println(element);
        }
    }

}