java泛型

java泛型

1.介绍:

1.表示集合中 保存的数据类型
2.E就代表要要保存的元素类型
3.jdk 1.7出来 菱形泛型
4.后面的<>里要跟前面的泛保持一致
5.如果前面声明了泛型 后面的泛型可以不写 不写表示类型一致

2.认识泛型

2.1定义三大类

2.11Persou类

/*
 * 姓名 和 年龄
 * 构造 set 和 toString
 * 创建一个学生类(构造方法 toString)继承人类
 */
public class Person {
private String name;
private int age;
public Person() {
    super();
    // TODO Auto-generated constructor stub
}
public Person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
}
@Override
public String toString() {
    return "Person [name=" + name + ", age=" + age + "]";
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
}

2.12定义Student类

.

public class Student extends Person {
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Student(String name, int age) {
        super(name, age);
        // TODO Auto-generated constructor stub
    }


}

2.12定义Work类

/*
 * 泛型类(泛型类声明时<>中的字母可以随便定义)
 * 泛型类的类型 在初始化这个类的对象 确定;
 */
public class Worker<W> {
    //利用泛型写成员变量
    private W w;
    //set/get方法
    public void setW(W w) {
        this.w = w;
    }
    public W getW() {
        return this.w;
    }
//普通成员变量
    public void sayHi(W w) {
System.out.println(w);
    }
//除了W不能其他泛型不能使用
//声明不同的方法 在调用泛型方法的时候 指定泛型的类型
//<Z>声明一个泛型 只要声明过才能使用   
    public static <Z> void print(Z z) {
        System.out.println(z);
    }
//工作
    public void work() {
        System.out.println("搬砖 一天400百");
    }
//静态方法中能不能直接调用  
//  当你调用静态方法的时候 可能还没有对象
//  没有对象就没有指定泛型 所有不能用
    public static<Q> void fun(Q q) {
        System.out.println(q);
    }
}

2.2泛型类的调用

public class text {
public static void main(String[] args) {
    //1.创建泛型对象
    Worker<String> worker = new Worker<>();
    worker.setW("@@");
    System.out.println(worker.getW());
    //2.调用成员方法
    worker.sayHi("@@");
    //3.调用方法给定类型
    Worker.print("Z号");
    //4.调用静态方法
    Worker.fun("石头人");

}
}

运行结果:
@@
@@
Z号
石头人

2.3打印学生姓名

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

    //创建集合 保存3个学生
    ArrayList<Student>students = new ArrayList<>();
    students.add(new Student("盆盆",12));
    students.add(new Student("盆盆",12));
    students.add(new Student("盆盆",12));
    students.add(new Student("盆盆",12));
Iterator<Student> iterator = students.iterator();
    Student next = (Student)iterator.next();
    System.out.println(next.getName());
    //编译通过
//  设置泛型可以把运行期的报错 在转换成编译期的报错
//  Worker worker = (Worker)iterator.next();
//  worker.work();

}
}
运行结果:  盆盆

2.4保存字符串

    ArrayList<String>list = new ArrayList<String>();
    list.add("a");      
    list.add("b");      
    list.add("c");      
    list.add("d");
    //迭代器
    //添加泛型后可以避免强转的麻烦
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        String next = iterator.next();
        System.out.println(next);

    }
}

运行结果:
a
b
c
d

3.? extend E(向下限定)与? super E

1.? extend Person E是父类 ?中只能填E的子类
2.? super E  ?是父类  E中只能填?的子类

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

    ArrayList<Person>persons = new ArrayList<>();
    persons.add(new Person("xsx",11));
    persons.add(new Person("xsq",11));
    ArrayList<Student>aList = new ArrayList<>();
    aList.add(new Student("盆盆",22));
    aList.add(new Student("试试",22));
    //学生集合添加到人类集合中
    persons.addAll(aList);
    System.out.println(persons);
}

}
运行结果:
[Person [name=xsx, age=11], Person [name=xsq, age=11], Person [name=盆盆, age=22], Person [name=试试, age=22]]

4.泛类把数组转化为集合

public class text {
public static void main(String[] args) {
    ////    Array 类方法 把数组转化为集合
    int[] array = new  int[]{1,2,3,4};
//  把数组 当做集合中的一个元素 转为了集合
    java.util.List<int[]> aList = Arrays.asList(array);

    Integer[] array2 = {1,2,3,4};
    java.util.List<Integer> aList2 = Arrays.asList(array2);
    System.out.println(aList);

    String[] array3 = {"wang long","wangson"};
    //数组转集合
    java.util.List<String> asList = Arrays.asList(array3);
    System.out.println(asList);
    //使用asList数组转集合 得到一个集合 这个集合不允许添加或删除操作
    //怎么转意义何在  可以调用集合的其他方法
    boolean contains = asList.contains("wangson");
    System.out.println(contains);
//  asList.add("wangjianazhog");//错误写法
    asList.set(0, "hgaga");
    System.out.println(asList);

运行结果:
[[I@33909752]
[wang long, wangson]
true
[hgaga, wangson]

}}

4.int…num遍历

public class text {
public static void main(String[] args) {
//int...num 相当于 传人的参数是个数组
int[]  array = {1,2,3,4};
fun2(10,array);
fun2(11,2,3,4,5);


}
public static void fun2(int j,int...num) {
    //遍历
//  int...num可以接受多个参数 只能是方法参数的最后一个
    for(int i = 0;i < num.length;i++) {
        System.out.println(num[i]);
    }
    System.out.println("j是" + j);
}
}

运行结果:
1
2
3
4
j是10
2
3
4
5
j是11

5. 删除集合元素

方法一:

private static void fun2() {
    ArrayList<String>list  =  new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("b");
    list.add("d");
    list.add("e");
    //获取迭代器
    Iterator<String>iterator = list.iterator();
    while (iterator.hasNext()) {
        String next = iterator.next();
        if (next.equals("b")) {
            iterator.remove();
        }       
    }
    System.out.println(list);
}

方法二:

private static void fun1() {
    //创建集合 保存 abcde
    ArrayList<String>list  =  new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("b");
    list.add("d");
    list.add("e");
//  不使用迭代器 遍历
//  如果集合中有b 就把b删除
for (int i = 0; i < list.size(); i++) {
    String string = list.get(i);
    if (string.equals("b")) {
        list.remove(i--);//先参与运算后减 
    }
}
        System.out.println(list);
}

运行结果:
[a,d,e]

增强for循环遍历

    ArrayList<String>list  =  new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("b");
    list.add("d");
    list.add("e");
    //增强for循环遍历  底层是使用迭代器遍历的
    //增强for循环只能用来遍历 也叫快速遍历
    //双层循环的时候 使用的比较多
    for (String string : list) {
        System.out.println(string);
    }

运行结果
a
b
b
d
e

6.集合排序

6.1按照姓名进行排序

//创建一个集合 存入 5个学生 按姓名 进行排序 封装成方法
    ArrayList<Student>list = new ArrayList<>();
    list.add(new Student("a",12));
    list.add(new Student("d",11));
    list.add(new Student("c",14));
    list.add(new Student("b",13));
    list.add(new Student("e",16));
    sortByName(list);

    System.out.println(list);
}
public static void sortByName(ArrayList<Student>list) {
    for (int i = 0; i < list.size() - 1; i++) {
        for (int j = 0; j < list.size() - 1 - i; j++) {
            //获取学生
            Student s1 = list.get(j);
            Student s2 = list.get(j + 1);
//          比较姓名
            if (s1.getName().compareTo(s2.getName()) < 0) {
                //交换
                Collections.swap(list, j + 1,j );
            }
        }
    }

运行结果:
[Person [name=e, age=16], Person [name=d, age=11], Person [name=c, age=14], Person [name=b, age=13], Person [name=a, age=12]]

6.2按照年龄进行排序

    //创建一个集合 存入 5个学生 按学生年龄 进行排序
    ArrayList<Student>list = new ArrayList<>();
    list.add(new Student("a",12));
    list.add(new Student("b",11));
    list.add(new Student("c",14));
    list.add(new Student("d",13));
    list.add(new Student("e",16));
    for (int i = 0; i < list.size() - 1; i++) {
        for (int j = 0; j < list.size() - 1 - i; j++) {
            Student ll = (Student)list.get(j);
            Student ss = list.get(j+1);
            if (ll.getAge()>ss.getAge()) {
                //交换(修改)在集合中的位置
                //set(int index ,Obj obj);
                list.set(j + 1, ll);
                list.set(j, ss);
            }
        }
    }
    System.out.println(list);
}

运行结果:
[Person [name=e, age=16], Person [name=d, age=11], Person [name=c, age=14], Person [name=b, age=13], Person [name=a, age=12]]

7.练习题

     创建一个java学科
     有2个班 班里有学生(使用泛型)
     遍历java学科里的学生

    //声明学科集合
     ArrayList<ArrayList<Student>> subject = new ArrayList<>();
     //声明班
    ArrayList<Student>classes1 = new ArrayList<>();
    classes1.add(new Student("王怂",11));
    classes1.add(new Student("建忠",12));
    ArrayList<Student>classes2 = new ArrayList<>();
    classes2.add(new Student("王怂1",11));
    classes2.add(new Student("建忠2",12));
    //把班添加到学科
    subject.add(classes1);
    subject.add(classes2);
    //遍历学科的学生
    //通过学科找到班
    for (ArrayList<Student>list : subject) {
         //通过班找到学生
        for (Student student : list) {
            System.out.println(student);
        }
    }

}

运行结果:
Person [name=王怂, age=11]
Person [name=建忠, age=12]
Person [name=王怂1, age=11]
Person [name=建忠2, age=12]