handsomecui的blog地址为：

本人网站为：

引言：本次主要练习单列集合：Collection,List,ArrayList,LinkedList,Vector,Set,HashSet,

1.Collect： 单列集合的跟接口；

2.List： 如果是实现了List接口的集合类，具备的特点： 有序，可重复

3.ArrayList：ArrayList的底层是使用了Object数组实现的，特点：查询速度快，增删慢

4.LinkedList：底层使用了链表数据结构实现的，特点：查询慢，增删快

5.Vector：底层使用了Object数组实现，实现与ArrayList一致，但是线程安全，操作效率低下

6.Set：如果实现了Set接口，具备的特点：无需，不可重复

7.HashSet：底层用哈希表实现的，特点：存取速度快

8.TreeSet：

　　(1)添加元素时，如果元素具备自然顺序的特点，那么TreeSet会根据元素自然顺序存取

　　(2)如果不具备自然顺序，那么元素所属的类就必须要实现Comparable接口，把比较的规则定义在ComepareTo的方法上。

　　(3)如果不具备自然顺序，而且元素所属的类也没有实现Comparable接口，那么必须在创建TreeSet对象的时候就必须传入比较器对象。

　　比较器的定义格式：

　　　　class 类名 implements Comparator{}

双列集合：

　　1.Map:存储的结构是以键值的形式存在的，键不可以重复，值可以重复

　　2.HashMap：底层也是用哈希表实现的。

　　3.TreeeMap：底层是红黑树数据结构实现的。

HashSet:

实例：

package com.java.base;import java.util.HashSet;class Person{    private int id;    private String name;    private int age;    public Person(int id, String name, int age){        this.name = name;        this.age = age;        this.id = id;    }    public String toString(){        return name + "的年龄是： " + age + "\n";    }    @Override    public int hashCode() {        // TODO Auto-generated method stub        return id;    }    @Override    public boolean equals(Object obj) {        Person person = (Person)obj;        return person.id == id;    }}public class hashSetLearn{    public static void main(String[] args){        HashSet
     
      hashset = new HashSet
      
       ();        hashset.add(new Person(10, "张三", 21));        hashset.add(new Person(11, "李四", 21));        hashset.add(new Person(11, "李四", 21));        System.out.println(hashset);    }}
      
     

往haset 中添加元素的时候会先用hashCode 的方法得到元素的hash值，然后把这个值经过运算得到位置，如果这个位置没有值，就放里面，如果有

就用equal的方法，如果true就重复，不允许添加，如果false就添加。

 集合的遍历：

 

package com.java.base;import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.Set;import java.util.Map.Entry;public class CollectVisited {    public static void main(String[] args) {        ArrayList
     
      list = new ArrayList
      
       ();        list.add("张三");        list.add("李四");        System.out.println("---------get方式遍历--------------");        for(int i = 0; i < list.size(); i++){            System.out.print(list.get(i));        }        System.out.println();                //注意迭代器使用过程不能添加删除元素        System.out.println("---------迭代器的第一种访问方式--------------");        Iterator
       
        iter = list.iterator();        while(iter.hasNext()){            System.out.print(iter.next() + ",");        }        System.out.println();                System.out.println("---------迭代器的第二种访问方式--------------");        for(String item : list){            System.out.print(item);        }        System.out.println();                System.out.println("----------hashmap的第一种遍历----------------");        HashMap
        
         map = new HashMap
         
          ();        map.put("张三", "001");        map.put("李四", "002");        map.put("王五", "003");        Set
          
           
            >entrys = map.entrySet();// for(Entry
            
             entry : entrys){ System.out.println(entry.getKey() + "的代号是：" + entry.getValue()); } System.out.println("----------hashmap的第二种遍历----------------"); Iterator
             
              
               >eiter = entrys.iterator(); while(eiter.hasNext()){ System.out.println(eiter.next()); } }}
              
             
            
           
          
         
        
       
      
     

 java 泛型练习：

泛型的好处：

 1.把运行时出现的问题提前至了编译时

 2.避免了无谓的强制类型转换。

  泛型方法的定义格式：

   修饰符<声明自定义泛型>返回值类型  函数名(形参列表。。。)

 泛型类的定义格式：

  class 类名<声明自定义泛型>{

  

  }

 泛型接口的定义格式：

  interface 接口名<声明自定义的泛型>{

  

  }

  注意：

   1.泛型中没有多态的概念，两边数据类型必须一致

   2.在方法上的自定义泛型的具体数据类型是调用该方法的时候传入的实参确定的

package com.java.base;import java.util.ArrayList;interface MyInterface
     
      {    public void add(T t);    public void remove(T t);}//自定义一个集合对象class MyList 
      
        implements MyInterface
       
         {    Object[] arr;    int index = 0;        public MyList(){        arr = new Object[10];    }    public void add(T o){        arr[index++] = o;    }    public int size(){        return index;    }    public T get(int i){        return (T)arr[i];    }    @Override    public void remove(T t) {        int j = -1;        for(int i = 0; i < index; i++){            if(((T)arr[i]).equals(t)){                j = i;                break;            }        }                for(; j < index - 1; j++){            arr[j] = arr[j + 1];        }        arr[index - 1] = null;        index--;    }}public class Genericity_exercise {/*泛型的好处：    1.把运行时出现的问题提前至了编译时    2.避免了无谓的强制类型转换。  泛型方法的定义格式：      修饰符
        <声明自定义泛型>
         返回值类型  函数名(形参列表。。。) 泛型类的定义格式：     class 类名
         <声明自定义泛型>
          {          } 泛型接口的定义格式：     interface 接口名
          <声明自定义的泛型>
           { } 注意： 1.泛型中没有多态的概念，两边数据类型必须一致 2.在方法上的自定义泛型的具体数据类型是调用该方法的时候传入的实参确定的*/ public static 
           
             T print(T o){ return o; } public static void main(String[] args) { ArrayList
            
             list = new ArrayList
             
              (); list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add("ddd"); for(int i = 0; i < list.size(); i++){ System.out.println(list.get(i).toUpperCase()); } System.out.println(print(213)); System.out.println(print("asfd")); MyList mylist = new MyList
              
               (); mylist.add("eee"); mylist.add("fff"); mylist.add("ggg"); mylist.add("hhh"); mylist.remove("fff"); for(int i = 0; i < mylist.size(); i++){ System.out.println(mylist.get(i)); } }}