java泛型 & 增强for循环foreach

一、泛型

1.为什么引入泛型？

package com.company01.generic;
/*
    关于JDK5.0新特性：泛型（编译器概念）

    1、为什么引入泛型？
        1.可以统一集合中的数据类型
        2.减少强制类型转换

    2、泛型语法如何实现？

    3、泛型的优点与缺点？
        优点：统一类型，减少强制类型转换
        缺点：只能存储一种类型

    以下程序没有使用泛型，缺点？
        如果集合不使用泛型，则集合中的元素类型不统一。
        在遍历集合的时候，只能拿出来Object类型，需要大量的强制类型转换，太麻烦。
*/
import java.util.*;

public class GenericTest01 {
    public static void main(String[] args) {

        // 创建一个集合，存储A、B、C
        Set s = new HashSet();

        // 创建对象
        A a1 = new A();
        B b1 = new B();
        C c1 = new C();

        // 添加元素
        s.add(a1);
        s.add(b1);
        s.add(c1);

        // 需求：遍历集合。如果是A类型，调用m1方法；如果是B类型，调用m2方法；如果是C类型，调用m3方法
        Iterator it = s.iterator();
        while(it.hasNext()){
            Object o = it.next();
            if(o instanceof A){
                A a = (A)o;
                a.m1();
            }else if(o instanceof B){
                B b = (B)o;
                b.m2();
            }else if(o instanceof  C){
                C c = (C)o;
                c.m3();
            }
        }


    }
}

class A{
    public void m1(){
        System.out.println("A's m1()...");
    }
}

class B{
    public void m2(){
        System.out.println("B's m2()...");
    }
}

class C{
    public void m3(){
        System.out.println("C's m3()...");
    }
}

2.泛型语法

2.1 List使用泛型

package com.company01.generic;
/*
    泛型语法如何实现？

    泛型是一个编译阶段的语法

    在编译阶段统一集合中的类型
*/
import java.util.*;
public class GenericTest02 {
    public static void main(String[] args) {

        // 创建一个List集合，只能存储字符串类型
        List<String> strs = new ArrayList<String>();

        // 添加元素
        //strs.add(1);  Error

        strs.add("Jack");
        strs.add("Tom");
        strs.add("Tony");
        strs.add("Smith");

        // 遍历
        Iterator<String> it = strs.iterator();

        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

2.2 Map使用泛型

package com.company01.generic;
/*
    Map使用泛型
*/
import java.util.*;
public class GenericTest03 {
    public static void main(String[] args) {

        Map<String, Integer> maps = new HashMap<String, Integer>();

        maps.put("西瓜", 10);
        maps.put("苹果", 5);
        maps.put("桃子", 4);
        maps.put("葡萄", 8);

        Set<String> keys = maps.keySet();
        Iterator it = keys.iterator();
        while(it.hasNext()){
            String k = (String) it.next();   // 这里it.next()返回的是Object类，还是需要强制转换
            Integer v = maps.get(k);
            System.out.println(k + "-->" + v);
        }
    }
}

2.3 SortedSet集合使用泛型

package com.company01.generic;
/*
    SortedSet集合使用泛型
*/
import java.util.*;
public class GenericTest04 {
    public static void main(String[] args) {
        SortedSet<Manager> ss = new TreeSet<Manager>();

        // 添加
        Manager m1 = new Manager(1000);
        Manager m2 = new Manager(1500);
        Manager m3 = new Manager(900);
        Manager m4 = new Manager(2000);

        ss.add(m1);
        ss.add(m2);
        ss.add(m3);
        ss.add(m4);

        // 遍历
        Iterator it = ss.iterator();
        while(it.hasNext()){
            Manager m = (Manager) it.next(); // 这里it.next()返回的是Object类
            System.out.println(m);
        }
    }
}

class Manager implements Comparable<Manager>{
    double sal;

    Manager(double sal){
        this.sal = sal;
    }

    public String toString(){
        return "Manager[sal:" + sal +"]";
    }

    public int compareTo(Manager m){
        double sal1 = this.sal;
        double sal2 = m.sal;

        if(sal1 < sal2){
            return -1;
        }else if(sal1 > sal2){
            return 1;
        }else{
            return 0;
        }
    }
}

3. 自定义泛型

package com.company01.generic;
/*
    自定义泛型
*/
public class GenericTest05 {
    public static void main(String[] args) {

        MyClass<String> mc = new MyClass<String>();

        // mc.m1(100);  // 传入int类型数据，编译失败
        mc.m1("100");
    }
}

// 自定义泛型
// 这里面的字母T是无所谓的，一般是 T 或者 E , T:type ; E:element
class MyClass<T>{
    public void m1(T t){
        System.out.println(t);
    }
}

二、增强for循环 foreach

package com.company01.generic;
/*
    关于增强for循环

    语法：
        for(类型 变量 : 数组名/集合名){}

    集合要想使用增强for循环这样语法，集合需要使用泛型。
    如果集合不使用泛型，该集合在用增强for循环的时候应该用Object类型定义
*/
import java.util.*;
public class ForeachTest01 {
    public static void main(String[] args) {

        int[] a = {1,2,3,4,5,6,76};

        //遍历
        for(int i=0; i<a.length; i++){
            System.out.println(a[i]);
        }
        System.out.println("=================");

        // foreach
        for(int e : a){
            System.out.println(e);
        }
        System.out.println("================");

        // 集合
        Set<String> strs = new HashSet<String>();

        strs.add("张三");
        strs.add("李四");
        strs.add("王五");
        strs.add("赵六");

        // 遍历
        for(String name : strs){
            System.out.println(name);
        }
        System.out.println("================");

        // 集合不使用泛型
        List l = new ArrayList();
        l.add(1);
        l.add(2);
        l.add(3);
        l.add(4);

        // 如果集合不使用泛型，该集合在用增强for循环的时候应该用Object类型定义。
        for(Object o : l){
        //for(Integer o : l){   // 【注意】即使这里写的是Integer也仍然会报错，尽管集合里面都是整型
                System.out.println(o);
        }
    }
}

package com.company01.generic;
import java.util.*;

public class ForeachTest02 {
    public static void main(String[] args) {

        Map<String, Integer> maps = new HashMap<String, Integer>();

        maps.put("西瓜", 10);
        maps.put("苹果", 5);
        maps.put("桃子", 4);
        maps.put("葡萄", 8);

        Set<String> keys = maps.keySet();

        for (String k : keys) {
            Integer v = maps.get(k);
            System.out.println(k + "-->" + v);
        }
    }
}

package com.company01.generic;
/*
    关于增强for的缺点：没有下标
*/
public class ForeachTest03 {
    public static void main(String[] args) {

        String[] ins = {"唱", "跳", "rap", "篮球"};

        StringBuffer sb = new StringBuffer();

        /*
        for(int i=0; i<ins.length; i++){
            if(i ==ins.length-1){
                sb.append(ins[i]);
            }else {
                sb.append(ins[i]);
                sb.append(",");
            }
        }
        System.out.println(sb);  //唱,跳,rap,篮球
        // 以上的循环就不适合使用增强for
         */

        for(String s : ins){
            sb.append(s);
            sb.append(",");
        }

        // 截取掉最后一个“,”

        System.out.println(sb.substring(0, sb.length()-1));  //subString[start, end);
    }
}