零基础学习java------day14-----泛型，foreach，可变参数，数组和集合间的转换，Set,Map，

1.泛型（jdk1.5以后出现）

https://www.cnblogs.com/lwbqqyumidi/p/3837629.html#!comments

（1）为什么要用泛型？

　　限制集合，让它只能存储某种类型的元素，如果不限制，集合（默认Object类型）中想存什么就存什么，这样在取元素的时候就会面临大量强制类型转换，这就很可能出现转换异常，为了解决这个问题，jdk1.5以后就出现泛型

　　当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。因此，当我们取出集合元素时需要人为的强制类型转化到具体的目标类型，这就很容易很容易出现“java.lang.ClassCastException”异常

（2）泛型概述

　　泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变化量话参数，此时类型也定义成参数形式（可称之为类型形参），然后在使用/调用时传入具体的类型（类型实参），一般用"<E>"表示。泛型只在编译时有效，在生成的.class文件中，会把泛型擦除掉。

（3）泛型定义

a  定义在类上

　若类在定义时没有加泛型时，则在创建对象时，不能使用泛型，如下图

此时Box定义时加上泛型，如下

public class GenericDemo {
    public static void main(String[] args) {
        Box<Integer> box = new Box<>(2);  //右边的尖括号内不需要写具体的可类型，jdk.7以后会根据左边自动识别出类型是什么
    }
}
class Box<T>{
    T t;              // T的类型是什么由创建对象时确定，如此处T就是Integer类型
    public Box(T t) {
        this.t = t;
    }
    public T getT() {
        return t;
    }
}

注意，类在创建对象时，不加泛型，默认是Object类型

b  定义在方法上（不常用）

用法：方法的逻辑相同，只是数据类型不同，这个时候使用反省方法，泛型写在返回值之前，以Collections中sort方法的源码为例

public static <T extends Comparable<? super T>> void sort(List<T> list) {
        list.sort(null);
    }

用了泛型后，sort方法中List中的参数类型就可以不同

public class GenericDemo {
    public static void main(String[] args) {
        String str = cast("aaa");
    }
    public static<E> E cast(Object o) {
        return (E)o;// 强制类型转换，向下转型
    }
}

c. 泛型定义在接口上

interface A<E>{
    public void test(E e);
}
// 如果实现的接口没有指定具体的类型，则子类必须泛型下去
class B<E> implements A<E>{
    public void test(E e) {

    }
}
// 如果实现的接口给定了具体的类型，子类中用到泛型的地方都必须使用该类型
class C implements A<String>{

    @Override
    public void test(String e) {

    }
}

 （4）泛型通配符

泛型通配符：

　　　　泛型通配符<?>

　　　　　　　　任意类型，如果没有明确，那么就是Object以及任意的java类了

　　　　　　？extends E

　　　　　　　　向下限定，E及其子类

　　　　　　？super E

　　　　　　　　向上限定，E及其父类

　　注意：泛型的通配值只能用在=的左边或者是参数列表上

public class GenericDemo2 {
    public static void main(String[] args) {
        Collection<?> c1 = new ArrayList<Animal>();
        Collection<?> c2 = new ArrayList<Dog>();
        Collection<?> c3 = new ArrayList<Cat>();
        Collection<?> c4 = new ArrayList<Object>();
        Collection<? extends Animal> c5 = new ArrayList<Animal>();
        Collection<? extends Animal> c6 = new ArrayList<Dog>();
        Collection<? extends Animal> c7 = new ArrayList<Cat>();
        //Collection<? extends Animal> c8 = new ArrayList<Object>();报错
        Collection<? super Animal> c9 = new ArrayList<Animal>();
        // Collection<? super Animal> c10 = new ArrayList<Dog>();报错
        // Collection<? super Animal> c11 = new ArrayList<Cat>();报错
        Collection<? super Animal> c12 = new ArrayList<Object>();
    }
}

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

2. foreach（增强for循环）

　　简化数组和Collection集合的遍历

　　格式：

　　　　　for(元素数据类型 元素名 ：数组或者Collection集合){对元素进行你自己的操作}

　　好处：简化遍历

　　注意事项：增强for的目标要判断是否为null

数组遍历

public class ForeachClass {
    public static void main(String[] args) {
        String[] str = new String[] {"哈","哈"};//当此处的数组为null时就会报java.lang.NullPointerException错误，所以要加验证，如下集合例子
        for(String a:str) {
            System.out.println(a);
        }
    }
}

集合的遍历

public class ForeachClass {
    public static void main(String[] args) {
        List<Person> ps = new ArrayList<>();
        ps.add(new Person("张三",27));
        ps.add(new Person("张一",17));
        ps.add(new Person("李四",37));
        ps.add(new Person("老王",67));
        ps.add(new Person("小红",25));
        if(ps!=null && ps.size()>0) {
            for(Person p:ps) {
                System.out.println(p);
            }
        }
    }
}
class Person{
    String name;
    int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

}

3. 可变参数

　　定义方法的时候不知道该定义多少个参数

格式：

　　修饰符  返回值类型  方法名（数据类型···  变量名）

注意：

　　这里的变量其实是一个数组

　　如果一个方法有可变参数，并且有多个参数，那么，可变参数必须是最后一个（若放前面的话，不能确定哪个参数时不可变参数）

案例

public class ChangeableParamDemo {
    public static void main(String[] args) {
        System.out.println(getSum(1,2,33));
    }
    public static int getSum(int b, int...a) {  //此变量a为数组
        int sum = 0;
        System.out.println(b);
        for(int i=0;i<a.length;i++) {
            sum += a[i];
        }
        return sum;
    }
}
// 运行结果：
1
35

4. 数组和集合间的转换

　　1.集合转数组;

　　 　　toArray(collection):   得到   Object[ ]

　　2.数组转集合：

案例

public class ArrayAndCollection {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("老王");
        list.add("小明");
        //1 集合转数组
        Object[] o = list.toArray();
        System.out.println(o);
        //2 数组转集合
        String[] str = {"1","2"};
        List<String> list1 = Arrays.asList(str);
        System.out.println(list1 instanceof List);//true
    }
}

注意，使用alist得到的集合是不能进行add和remove操作的（只能是可读的集合，

原因：此处asList返回的是一个ArrayList对象，但这个ArrayList是Arrays里面的内部类，这个类中没有实现增加和删除的方法　　

如果非要操作，需要创建一个新的集合，把它传入到构造方法中，如下

Integer[] arr = {1,2};
List<Integer> list1 = Arrays.asList(arr);
List<Integer> list2 = new ArrayList<>(list1);
list2.add(100);
System.out.println(list2);//[1, 2, 100]

5.Set

（1）

特点：Set的元素时无序的（不能使用索引操作元素），元素不可重复

collection：

　　　List():  有序的，元素可重复

　　　　　　   ArrayList

　　　　　　　LinkedList：特有方法（增删，获取集合首个和最后一个元素）

　　   Set(): 无序的（不能使用索引操作元素），元素不能重复

　　　　　　HashSet：无法保证存入和取出的顺序

　　　　　　LinkedHashSet：可以保证存入和取出的顺序（链表实现）

　　　　　　TreeSet：有序的（可以对元素排序）

不可重复性的原理：

　　是由hashCode和equals方法保证的

　　存放元素的时候，先求出元素的hashCode，如果集合中没有这样的hashCode值，说明该元素在集合中不存在，可以存；有这样的hashCode，再比较equals：如果为true，集合中已经存在噶元素，则不存，如果为false，则可以存。

案例

public class SetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("小猫警长");
        set.add("黑猫警长");
        set.add("白猫警长");
        set.add("花猫警长");
        set.add("白猫警长");
        set.add("花猫警长");
        set.add("黑猫警长");
        set.add("红猫警长");
        System.out.println(set);
    }
}
// 运行结果：[黑猫警长, 红猫警长, 白猫警长, 花猫警长, 小猫警长]

可见存入的顺序并不有序，若想有序可以使用LinkedHashSet创建对象

（2）Set的遍历（三种方法）

第一种：数组

public class SetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("小猫警长");
        set.add("黑猫警长");
        set.add("白猫警长");
        set.add("花猫警长");
        set.add("红猫警长");
        Object[] array = set.toArray();
        for(Object s:array) {
            System.out.println(s);
        }
   }
}

第二种：迭代器

Iterator<String> it = set.iterator();
while(it.hasNext()) {
    System.out.println(it.next());
}

第三种（增强for循环）

for(String str :set) {
    System.out.println(str);
}

练习：

1. 使用LinkedHashSet填写一个程序，获取10个1至20的随机数，要求随机数不能重复

public class TenNum {
    public static void main(String[] args) {
        Set<Integer> set = new LinkedHashSet<>();
        Random r = new Random();
        while(set.size()<10) {
            int num = r.nextInt(20)+1;
            set.add(num);
        }
        System.out.println(set);
    }
}

2. 使用集合去重

public class SetQuChong {
    public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(1);
    list.add(2);
    list.add(2);
    List<Integer> list1 = distinct(list);
    System.out.println(list1);
    }
    public static List<Integer> distinct(List<Integer> list){
        Set<Integer> set = new HashSet<>();
        set.addAll(list);
        list.clear();
        list.addAll(set);
        return list;
    }
}
// 运行结果：[1,2]

6. Map

6.1 概述

　　双列集合的跟接口；将键映射到值的对象；一个映射不能包含重复的键，每个键最多只能映射到一个值。

Map接口和Collection接口的不同：

　　Map是双列的，Colection是单列的

　　Map的键唯一（值可以不唯一），Collection的子体系只有Set是唯一的

6.2 Map接口的成员方法

V put(K key,V value) 添加元素(返回值是Key上一次对应的Value)
V remove(Object key) 移除key对应的键值对（返回值是value）
void clear() 清空map
boolean containsKey(Object key) 是否包含key
boolean containsValue(Object value) 是否包含value
boolean isEmpty() 是否为空
int size() 键值对的个数

V put(K key,V value) 添加元素(返回值是Key上一次对应的Value)

public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        String re = map.put("a","啊，五环，你比四环多一环");
        System.out.println(re);
        String re1 = map.put("a","啊，四环，你比五环少一环");
        System.out.println(re1);
    }
}
//运行结果：
null
啊，五环，你比四环多一环

由结果可知，put的返回值为当次被覆盖的内容（第一次打印的结果为null，相当于第一次添加值将null覆盖）

V remove(Object key) 移除key对应的键值对（返回值是被移除键值对中的value）

System.out.println(map);//{a=啊，四环，你比五环少一环}
String re2 = map.remove("a");
System.out.println(re2);//啊，四环，你比五环少一环

get(key) 方法（可用于遍历）,返回值为key所对应的值

System.out.println(map);//{a=啊，四环，你比五环少一环}
String re3 = map.get("a");
System.out.println(re3);//啊，四环，你比五环少一环

6.3 Hashmap的遍历

第一种  keySet  获取所有key

public class MapDemo {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1, "小明");
        map.put(2, "小红");
        map.put(3, "小王");
        map.put(4, "小李");
        Set<Integer> keySet = map.keySet();
        for(Integer key:keySet) {
            System.out.println("key:"+key+",value:"+map.get(key));
        }
    }
}

第二种  entrySet（获取键值对）

Set<Entry<Integer, String>> entrySet = map.entrySet();
for (Entry<Integer, String> entry:entrySet) {
　　System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}

使用迭代器实现：

Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();

while(it.hasNext()) {
    System.out.println(it.next());
    System.out.println("key:"+next.getKey()+",value:"+next.getValue());
}

第三种  values：只能得到所有的value

Collection<String> values = map.values();
for (String v :values) {
    System.out.println(v);
}

6.4 HashMap的实现原理

使用散列表（由数组和链表组成）或哈希表来实现的（效率高）

数组+链表：元素是链表的数组（主体是数组）

练习：统计一个字符串中各个字符出现的次数

public class StrTimes {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.nextLine();
        // 创建map，用来存储数据
        Map<Character, Integer> map = new HashMap<>();
        // 遍历获取每一个字符
        for(int i=0;i<str.length();i++) {
            char ch = str.charAt(i);
            //用ch做key去map中查询是否有值
            Integer value = map.get(ch);
            if(value == null) {
                map.put(ch, 1);
            }else {
                value++;
                map.put(ch,value);
            }
        }
        Set<Character> keySet = map.keySet();
        for(Character c:keySet) {
            System.out.println("字符"+c+"的次数:"+map.get(c));
        }
    }
}