java 集合专练

handsomecui的blog地址为：http://www.cnblogs.com/handsomecui/

本人网站为：handsomecui.top

引言：本次主要练习单列集合：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 + "
";
    }
    @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<Person>hashset = new HashSet<Person>();
        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<String>list = new ArrayList<String>();
        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<String>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<String, String>map = new HashMap<String, String>();
        map.put("张三", "001");
        map.put("李四", "002");
        map.put("王五", "003");
        Set<Entry<String, String>>entrys = map.entrySet();//
        for(Entry<String, String>entry : entrys){
            System.out.println(entry.getKey() + "的代号是：" + entry.getValue());
        }
        
        System.out.println("----------hashmap的第二种遍历----------------");
        Iterator<Entry<String, String>>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<T>{
    public void add(T t);
    public void remove(T t);
}

//自定义一个集合对象
class MyList <T> implements MyInterface<T> {
    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> T print(T o){
        
        return o;
    }
    public static void main(String[] args) {
        
        ArrayList<String>list = new ArrayList<String>();
        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<String>();
        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));
        }
        
    }

}