StJavaDay05

集合体（一）

StringBuffer

扩容：*2+2；

Collection

Collection集合常用方法

import java.util.ArrayList;
import java.util.Collection;
/*
* Collection集合常用方法
* boolean add(E e)增加元素
* boolean remove(Object o)从集合中移除指定的元素
* void clear()清空集合中的元素
* boolean contains(Object o)判断集合中是否存在指定的元素
* boolean isEmpty()判断集合是否为空
* int size()集合的长度，元素的个数
*
* alt+7 打开一个窗口，能够看到所有类的信息
* */
public class CollectionDemo {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c=new ArrayList<String>();
        //增加元素;boolean add(E e)
       c.add("my name is shady");
        c.add("i am a foolish man");
        c.add("shut your moush");

        //System.out.println(c);

        //boolean remove(Object o)从集合中移除指定的元素

       /* c.remove("my name is shady");
        System.out.println(c);*/

        //void clear()清空集合中的元素
       /* c.clear();
        System.out.println(c);*/

        //boolean contains(Object o)判断集合中是否存在指定的元素

       // System.out.println(c.contains("world"));



    }
}

Collection集合的遍历

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

public class IteratorDemo {

    /*
     * Iterator:迭代器 ，集合的专用遍历方式
     *   Iterator<E> iterator():返回集合中元素的迭代器，通过集合的iterator()方法得到
     *
     * Iterator中的常用方法
     *    E next():返回迭代中的下一个元素
     *    boolean hasNext():如果迭代具有更多元素，则返回ture
     * */

    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c=new ArrayList<String>();
        //增加元素;boolean add(E e)
        c.add("my name is shady");
        c.add("i am a foolish man");
        c.add("shut your moush");

        Iterator<String> it = c.iterator();

        // E next():返回迭代中的下一个元素
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());//NoSuchElementException 表示被请求的元素不存在

        //  boolean hasNext():如果迭代具有更多元素，则返回ture
        while(it.hasNext())
        {
            String s=it.next();
            System.out.println(s);
        }
    }
}

List

   /*
    * List集合
    * 有序集合，用户可以精确控制控制列表中每个元素的插入位置。用户可以通过整数索引访问元素
    * 与Set集合不同，列表通常允许重复的的元素
    *
    * List集合的特点
    * 有序：存储和取出的元素顺序一致（队列）
    * 可重复
    *
    *
    * List集合特有的方法
    * void add(int index,E element)//指定位置插入元素
    * E remove(int index)
    * E set(int index,E element)修改指定索引出的元素
    * E get(int index)
    * */
	

ArrayList

扩容

默认大小10
第一次扩容15
第二次扩容22
扩容规则：*2向右移动一位

特点

数组实现
查询快
增删慢

LinkedList

特点

双向链表
增删快
查询慢

Set

Set集合概述和特点

1. 元素存取无序
2. 没有索引、只能通过迭代器或增强for循环遍历
3. 不能存储重复元素

哈希值

哈希值的特点

1. 同一个对象多次调用hashCode()方法返回的哈希值是相同的
2. 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

HashSet集合特点

HashSet集合的特点

1. 底层数据结构是哈希表
2. 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
3. 没有带索引的方法，所以不能使用普通for循环遍历
4. 由于是Set集合，所以是不包含重复元素的集合
5. 线程不安全
6. 可以保存null

LinkHashSet

TreeSet

1. TreeSet()：根据其元素的自然排序进行排序
2. TreeSet(Comparator comparator) ：根据指定的比较器进行排序
3. 不可保存null

TreeMap

1. key不能为空

Hashtable

1. value不能为空
2. key不能为null
3. 线程安全

Vector

特点

1. 线程安全
2. 有序

自然排序Comparable的使用

就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法

@Override
    public  int compareTo(Student s){

//        return 0 重复
//        return 1 升序
//        return -1 降序

        int num=this.age-s.age;//升序
        int num2=num==0?this.name.compareTo(s.name):num;
        return num2;

比较器排序Comparator的使用

集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法

泛型

优势

1. 把运行时期的问题提前到了编译期间
2. 避免了强制类型转换

泛型类

  public class Generic<T> {
            private T t;

            public T getT() {
                return t;
            }

            public void setT(T t) {
                this.t = t;
            }
        }

泛型方法

public class Generic {
        public <T> void show(T t) {
            System.out.println(t);
        }
    }

泛型接口

//定义泛型接口
public interface Generic<T> {
        void show(T t);
    }

//泛型接口实现类
public class GenericImpl<T> implements Generic<T> {
        @Override
        public void show(T t) {
            System.out.println(t);
        }
    }
//测试类

public class GenericDemo {
        public static void main(String[] args) {
            Generic<String> g1 = new GenericImpl<String>();
            g1.show("at");
            Generic<Integer> g2 = new GenericImpl<Integer>();
            g2.show(30);
        }
    }

类型通配符

类型通配符：<?>
List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
类型通配符上限：<? extends 类型>
List<? extends Number>：它表示的类型是Number或者其子类型
类型通配符下限：<? super 类型>
List<? super Number>：它表示的类型是Number或者其父类型

可变参数

可变参数放在最后，且方法中仅有一个可变参数
Arrays工具类中有一个静态方法：

public static List asList(T… a)：返回由指定数组支持的固定大小的列表

返回的集合不能做增删操作，可以做修改操作

List接口中有一个静态方法：
public static List of(E… elements)：返回包含任意数量元素的不可变列表

返回的集合不能做增删改操作

Set接口中有一个静态方法：
public static Set of(E… elements) ：返回一个包含任意数量元素的不可变集合

在给元素的时候，不能给重复的元素

返回的集合不能做增删操作，没有修改的方法