Java学习笔记（集合_2）

16 集合

16.3 泛型

在引入范型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入范型后，一个复杂类型
就可以在细分成更多的类型。
例如原先的类型List，现在在细分成List, List等更多的类型。

格式：通过<>定义要操作的引用数据类型，其实<>就是用来接收类型的。

泛型类定义的泛型：在整个类中有效， 如果被方法使用，那么泛型的对象明确要操作的具体类型后，所有要操作的类型就已经固定。

静态方法不可以访问类上定义的泛型，如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

泛型定义方法时<>放在修饰符后，返回值类型前。
例1：

public class GenericDemo {
    public static void main(String[] args) {
        Demo<Integer> d = new Demo<Integer>();

        d.show(new Integer(2));
        d.print(9);

        Demo<String> s = new Demo<String>();

        s.show("ssa");
        s.print("asfdaf");

        Demo.method("gabriel");
    }
}

class  Demo<T>{
    public void show(T t){
        System.out.println("show:"+t);
    }
    public<Q> void print(Q q){
        System.out.println("print:"+q);
    }
    public static<W> void method(W w){
        System.out.println("method:"+w);
    }
}

运行结果：

例2：

public class GenericDemo {
    public static void main(String[] args) {
        InterImpl<Integer> i = new InterImpl<Integer>();
        i.show(3);
    }
}
interface Inter<T>{
    void show(T t);
}

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

运行结果：3

通配符？，也可以理解为占位符。

16.4 Map接口

当数据之间存在映射关系时，可以使用map集合。

常用方法：

1. 添加
   value put(key,value):返回前一个和key关联的值，如果没有返回null。
   
   • 删除
     void clear():清空map集合。
     value remove(Object key):根据指定的key删除这个键值对。
   • 判断
     boolean containsKey(key);
     boolean containsValue(value);
     boolean isEmpty();
   • 获取
     value get(key):通过键获取值，如果没有该键返回null。
     当然可以通过返回null，来判断是否包含指定键。
     int size():获取键值对个数。

Map包含：

1. Hashtable:底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的，jdk1.0，效率低；
2. HashMap：底层是哈希表数据结构，允许使用null值和null键，该集合是不同步，jdk1.2，效率高。

3. TreeMap：底层是二叉树数据结构，线程不同步。可以用于给Map集合中的键进行排序。
   例1：

   import java.util.Collection;
   import java.util.HashMap;
   import java.util.Map;
   
   public class MapDemo {
   
       public static void main(String[] args) {
           Map<String,String> map = new HashMap<String,String>();
           //添加元素，同一个键后添加的值会覆盖原对应值，并返回原有值
           System.out.println(map.put("1", "Gabriel1"));
           System.out.println(map.put("1", "Gabriel6"));
           map.put("2", "Gabriel2");
           map.put("3", "Gabriel3");
   
           System.out.println("containsKey:"+map.containsKey("1"));
           System.out.println("get:"+map.get("3"));
           System.out.println("remove:"+map.remove("1"));
           System.out.println(map);
   
           Collection<String> col = map.values();
           System.out.println(col);
       }
   }
   

   运行结果：

Map集合的取出方式：
1. map集合转成set集合（keySet()方法），再通过迭代器取出，如例2；
2. entrySet()：将map集合中的映射关系存入到set集合中，而这个关系的数据类型就是Map.Entry，如例3。

例2:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("2", "Gabriel2");
        map.put("3", "Gabriel3");
        map.put("1", "Gabriel1");
        map.put("4", "Gabriel4");

        Set<String> keySet = map.keySet();
        Iterator<String> it = keySet.iterator();
        while(it.hasNext()){
            String key = it.next();
            //有键后通过map集合的get方法获取其对应的值
            String value = map.get(key);
            System.out.println("key:"+key+"+value:"+value);
        }
    }
}

运行结果：

例3：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("2", "Gabriel2");
        map.put("3", "Gabriel3");
        map.put("1", "Gabriel1");
        map.put("4", "Gabriel4");

        Set<Map.Entry<String,String>> entrySet = map.entrySet();

        Iterator<Map.Entry<String,String>> it = entrySet.iterator();
        while(it.hasNext()){
            Map.Entry<String,String> me = it.next();
            System.out.println(me.getKey()+".."+me.getValue());
        }
    }
}

运行结果：

例4：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapTest {

    public static void main(String[] args) {
        HashMap<Student1,String> hm = new HashMap<Student1,String>();
        hm.put(new Student1("Gabriel1",21), "上海");
        hm.put(new Student1("Gabriel1",21), "南京");
        hm.put(new Student1("Gabriel2",22), "北京");
        hm.put(new Student1("Gabriel3",23), "广州");
        hm.put(new Student1("Gabriel4",24), "杭州");
        System.out.println("/*****第一种取出方式：********/");
        Set<Student1> keySet = hm.keySet();
        Iterator<Student1> it = keySet.iterator();
        while(it.hasNext()){
            Student1 stu = it.next();
            String address = hm.get(stu);
            System.out.println(stu+"..."+address);
        }
        System.out.println("/******第二种取出方式：*******/");
        Set<Map.Entry<Student1, String>> entrySet= hm.entrySet();
        Iterator<Map.Entry<Student1, String>> it1 = entrySet.iterator();
        while(it1.hasNext()){
            Map.Entry<Student1, String> me = it1.next();
            System.out.println(me.getKey()+"..."+me.getValue());
        }
    }

}
class Student1 implements Comparable<Student1>{

    private String name;
    private int age;
    Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String toString(){
        return name+":"+age;
    }
    //重写hashCode方法
    public int hashCode() {
        return name.hashCode()+age;
    }

    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student1 other = (Student1) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    public int compareTo(Student1 s) {
        int num = new Integer(this.age).compareTo(new Integer(s.age));
        if(num == 0)
            return this.name.compareTo(s.name);
        return num;
    }
}

运行结果:

为何要重写hashCode()方法可参见：
http://blog.csdn.net/liushuai_ly/article/details/8197508

16.5 Arrays工具类

Arrays:集合框架的工具类，其中的方法均为静态。

16.5.1 数组变集合

Arrays中的asList(数组)将数组转换为集合，如例5。

例5：

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {
    public static void main(String[] args) {
        String[] arr = {"abc","cc","xyz"};

        List<String> list = Arrays.asList(arr);
        boolean b = list.contains("ac");
        System.out.println(b);
    }
}

运行结果：false

P.S.
数组的长度是固定的，所以对于结合的增删方法是不可以使用的，否则，会发生UnsupportedOperationException。

如果数组中的元素都是对象，变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素是基本数据类型，那么会将该数组作为集合中的元素存在，如例6。

例6：

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {
    public static void main(String[] args) {
        String[] arr = {"abc","cc","xyz"};

        List<String> list = Arrays.asList(arr);
        /*boolean b = list.contains("ac");
        System.out.println(b);*/

        Integer[] nums = {1,3,2};
        List<Integer> li = Arrays.asList(nums);
        System.out.println(li);
    }
}

运行结果：[1, 3, 2]

16.5.2 集合变数组

Collection接口中的toArray方法。

1. 当指定类型的数组长度小于集合的size，则该方法内部会创建一个新的数组，长度为集合的size；
2. 当指定类型的数组长度大于集合的size，则不会新创建数组，而是使用传递进来的数组，所以创建一个刚好的数组最优。

集合变数组是为了限制元素的操作，不需进行增删。

例7：

import java.util.ArrayList;
import java.util.Arrays;

public class CollectionToArray {

    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String> ();

        al.add("a1");
        al.add("a2");
        al.add("a3");

        String[] arr = al.toArray(new String[6]);

        System.out.println(Arrays.toString(arr));
    }
}

运行结果：[a1, a2, a3, null, null, null]

高级for循环：for(数据类型 变量名：被遍历的集合(Collection)或者数组){}

对集合进行遍历，只能获取集合元素，不能对集合进行操作。而迭代器

例8：

import java.util.ArrayList;

public class ForEachDemo {

    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<String>();

        arr.add("a1");
        arr.add("a2");
        arr.add("a3");

        for(String s : arr){
            s = "c";
            System.out.println(s);
        }
        System.out.println(arr);
    }
}

运行结果：

例9：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class ForEachDemo {

    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<String>();

        arr.add("a1");
        arr.add("a2");
        arr.add("a3");

        for(String s : arr){
            s = "c";
            System.out.println(s);
        }
        System.out.println(arr);

        int[] al = {1,3,4};
        for(int i :al){
            System.out.println("i:"+i);
        }

        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1, "a");
        hm.put(2, "b");
        hm.put(3, "c");
        Set<Integer> keySet = hm.keySet();
        for(Integer i : keySet){
            System.out.println(i+"::"+hm.get(i));
        }

        for(Map.Entry<Integer, String> me:  hm.entrySet()){
            System.out.println(me.getKey()+"---"+me.getValue());
        }   
    }
}

运行结果：

方法的可变参数：
就是
在使用时注意，可变参数一定要定义在参数列表最后面

例10：

public class ParamMethodDemo {

    public static void main(String[] args) {
        show("a",1,2,3,4);
        show("c",1,2,3,4,5);
    }
    public static void show(String a,int... arr){
        System.out.print(arr.length+a);
    }
}

运行结果：45ac

静态导入：
导入的该类中所有静态成员。

import java.util.*;
import static java.util.Arrays.*;//导入Arrays这个类中的所有静态成员
public class StaticImportDemo {

    public static void main(String[] args) {
        int[] arr = {4,3,5};
        Arrays.sort(arr);
        int index =binarySearch(arr, 1);
        System.out.println(Arrays.toString(arr));//当类名重名时，需要制定具体的包名；
        //当方法重名时，需要制定具备所属的对象或类。
        System.out.println("Index:"+index);
    }
}

运行结果：