泛型概述和基本使用
泛型机制：JDK1.5之后引入的一个概念
A:泛型概述:是一种把类型明确的工作推迟到创建对象或调用方法时，才去明确的一种机制。
或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。
B:泛型的格式 : <数据类型，数据类型> 这里的数据类型只能是引用数据类型
C:泛型好处
(1): 把运行时期的问题提前到了编译期间
(2): 避免了强制类型转换
(3):优化了程序设计，解决了黄色警告线，提高程序的扩展性
注意：泛型只在编译期有效 但在运行期就擦除了
//JDK1.7之前 泛型前面后面都得写上，JDK1.7可以省略右半边不写
D:泛型基本使用
案例一：
public class MyTest {
public static void main(String[] args) {
//泛型机制：JDK1.5之后引入的一个概念
//把类型明确工作，推迟到创建对象，或调用方法时，才去明确的一种机制。
//泛型的语法：<数据类型,数据类型>
//泛型可以加在 接口上，类型，方法上
//泛型的好处：1.避免了向下转型，2.将问题提前到了编译期
//泛型的特点：泛型只在编译期有效，在运行期就擦除了。
//泛型可以限定，我这个集合中存储什么样的引用数据类型
//JDK1.7之前 泛型前面后面都得写上，JDK1.7可以省略右半边不写
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
//泛型可以避免向下转型
ArrayList list2 = new ArrayList();
list2.add("aaaaa");
list2.add("bbbb");
list2.add("ccc");
list2.add("ddd");
Object obj = list2.get(0);
String string= (String) obj;
int length = string.length();
ArrayList<String> list3= new ArrayList();
list3.add("aaaaa");
list3.add("bbbb");
list3.add("ccc");
list3.add("ddd");
String s = list3.get(0);
System.out.println(s);
}
}
注意：集合都会去使用泛型，明确我集合中，该添加何种数据类型的元素
案例二：
import java.util.ArrayList;
import java.util.Iterator;
public class MyTest2 {
public static void main(String[] args) {
//泛型的使用，就避免了向下转型
ArrayList<Integer> list= new ArrayList();
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
// Integer integer = list.get(0);
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()){
Integer ele = iterator.next();
System.out.println(ele);
}
}
}
注意：
泛型的使用，就避免了向下转型
ArrayList存储自定义对象并遍历泛型版
案例一：
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
list.add(new Student("张三",23));
list.add(new Student("张三", 23));
list.add(new Student("张三", 23));
list.add(new Student("张三", 23));
list.add(new Student("张三", 23));
list.add(new Student("张三", 23));
list.add(new Student("张三", 23));
list.add(new Student("张三", 23));
list.add(new Student("张三", 23));
for (int i = 0; i < list.size(); i++) {
Student student = list.get(i);
System.out.println(student.getName()+"=="+student.getAge());
}
}
}
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
案例二：
public class MyTest {
public static void main(String[] args) {
MyObject myObject = new MyObject();
myObject.setObj("abc");
Object obj = myObject.getObj();
String str= (String) obj;
System.out.println(str.length());
System.out.println("-----------------");
MyObject myObject1 = new MyObject();
myObject1.setObj(100);
Object obj1 = myObject1.getObj();
Integer integer= (Integer) obj1;
System.out.println(integer.intValue());
}
}
public class MyTest {
public static void main(String[] args) {
MyObject myObject = new MyObject();
myObject.setObj("abc");
Object obj = myObject.getObj();
String str= (String) obj;
System.out.println(str.length());
System.out.println("-----------------");
MyObject myObject1 = new MyObject();
myObject1.setObj(100);
Object obj1 = myObject1.getObj();
Integer integer= (Integer) obj1;
System.out.println(integer.intValue());
}
}
泛型类的概述及使用
A:泛型类概述: 把泛型定义在类上
B:定义格式: public class 类名<泛型类型1,…>
C:注意事项: 泛型类型必须是引用类型
格式: public class 类名<数据类型 , …> {}
*/
public class ObjectTools {
private K k ;
public K getK() {
return k;
}
public void setK(K k) {
this.k = k;
}
}
案例一：
public class MyObject<M, U> { //泛型类 ，将泛型加在类上面
private M m;
private U u;
//private int a;
//private String b;
public M getM() {
return m;
}
public void setM(M m) {
this.m = m;
}
public U getU() {
return u;
}
public void setU(U u) {
this.u = u;
}
}
public class MyTest {
public static void main(String[] args) {
//泛型机制：是JDK1.5之后，引入的一种机制
// 泛型，是把类型明确工作，推迟到，创建对象，或调用方法时，再去明确的一种机制
MyObject<String, Integer> object = new MyObject<>();
object.setM("abc");
object.setU(100);
String m = object.getM();
Integer u = object.getU();
}
}
泛型方法的概述和使用
A:泛型方法概述: 把泛型定义在方法上
B:定义格式: public <泛型类型> 返回类型 方法名(泛型类型 变量名)
C:案例演示: 泛型方法的使用
public class Phone {
/**
泛型方法
*/
public void show(E e){
System.out.println(e);
}
}
案例一：
public class MyDemo {
//public void show(Integer num){
// System.out.println(num);
//}
//
//public void show(String num) {
// System.out.println(num);
//}
//
//public void show(Double num) {
// System.out.println(num);
//}
//
//public void show(Character num) {
// System.out.println(num);
//}
//public void show(Object num) {
//
//
// System.out.println(num);
//}
//泛型方法
public <T> void show(T num) {
System.out.println(num);
}
}
public class MyTest {
public static void main(String[] args) {
// //泛型机制：是JDK1.5之后，引入的一种机制
// // 泛型，是把类型明确工作，推迟到，创建对象，或调用方法时，再去明确的一种机制
MyDemo myDemo = new MyDemo();
myDemo.show(2.1);
myDemo.show(100);
myDemo.show("abc");
}
}
泛型接口的概述和使用
A:泛型接口概述: 把泛型定义在接口上
B:定义格式: public interface 接口名<泛型类型>
C:案例演示: 泛型接口的使用
public interface Inter {
public abstract void show(T t) ;
}
/**
泛型接口的子类: 第一种情况: 就是在定义子类的时候我们已经可以明确数据类型了
/
//public class InterImpl implements Inter {
//
// @Override
// public void show(String t) {
// System.out.println(t);
// }
//
//}
/*
泛型接口的子类: 第二种情况: 就是在定义子类的时候我们还不知道到底使用神马数据类型.这个时候我们就需要将这个子类定义
成泛型
*/
public class InterImpl implements Inter {
@Override
public void show(T t) {
System.out.println(t);
}
}
案例一：
public interface MyInterface<Y,M,E> {//泛型接口
Y set(M m,E e);
}
//接口上的泛型，在具体的实现类上 就可以明确
public class MyClass implements MyInterface<Integer,Integer,Integer>{
@Override
public Integer set(Integer integer, Integer integer2) {
return 100;
}
}
public class MyTest {
public static void main(String[] args) {
//使用匿名内部类，在创建接口的子类对象时，如果接口上加有泛型，那么需要明确泛型的具体类型
new MyInterface<String, String, String>() {
@Override
public String set(String s, String s2) {
return null;
}
};
}
}
泛型高级之通配符
A:泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E: 向下限定，E及其子类
C:? super E: 向上限定，E及其父类
D:案例演示: 泛型高级之通配符的基本使用
/**
- 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
*/
Collection col1 = new ArrayList() ;
Collection col2 = new ArrayList() ;//报错
// ? 表示任意的数据类型
Collection<?> col5 = new ArrayList<Object>() ;
Collection<?> col6 = new ArrayList<Animal>() ;
// ? extends E : 向下限定 , ? 表示的是E或者E的子类
// Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错
Collection<? extends Animal> col10 = new ArrayList<Animal>() ;
Collection<? extends Animal> col11 = new ArrayList<Dog>() ;
// ? super E: 向上限定 , ? 表示的是E或者E的父类
Collection<? super Animal> col13 = new ArrayList<Object>() ;
Collection<? super Animal> col14 = new ArrayList<Animal>() ;
// Collection<? super Animal> col15 = new ArrayList() ;//报错
案例一：
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
//泛型通配符
ArrayList<?> objects = new ArrayList<Dog>();
//向上限定
ArrayList<? super Animal> objects2 = new ArrayList<Object>();
ArrayList<? super Animal> objects3 = new ArrayList<Animal>();
//ArrayList<? super Animal> objects4 = new ArrayList<Dog>(); 错误的
//向下限定
ArrayList<? extends Animal> objects5 = new ArrayList<Animal>();
ArrayList<? extends Animal> objects6 = new ArrayList<Dog>();
ArrayList<? extends Animal> objects7 = new ArrayList<Cat>();
// ArrayList<? extends Animal> objects8 = new ArrayList<Object>(); 错误的
ArrayList<Integer> integers = new ArrayList<>();
integers.add(100);
ArrayList<Integer> integers2 = new ArrayList<>();
integers2.add(10);
integers.addAll(integers2);
}
}
class Animal {
}
class Dog extends Animal {
}
class Cat extends Animal {
}
增强for的概述和使用
A:增强for概述
简化数组和Collection集合的遍历
B:格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
C:案例演示
数组，集合存储元素用增强for遍历
D:好处和注意事项
简化遍历
注意事项：增强for的目标要判断是否为null
案例一：
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList();
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
//list.iterator();
//list.listIterator();
//遍历
//for (int i = 0; i < list.size(); i++) {
//
//}
//
//JDK1.5引入一种新的循环方式，可以用来遍历数组和集合
int[] arr={1,4,6,9,5};
//for (int i = 0; i < arr.length; i++) {
// System.out.println(arr[i]);
//}
//
//第一点：先确定你容器中的元素的数据类型
// 第二个就是容器的名字
//for(int a:arr){
// System.out.println(a);
//}
//for(Integer ele:list){
// System.out.println(ele);
//}
//for (Integer integer : list) {
//
//}
//for (int i = 0; i < list.size(); i++) {
//
//}
//for (Integer integer : list) {
//
//}
}
}
注意几种遍历方式：
迭代器：iterator//listIterator
for 新式for循环
ArrayList存储自定义对象并遍历增强for循环
注意使用新式for循环在遍历集合的途中，如果你往集合中添加，或删除元素时，会报并发修改异常
案例一：
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
public class MyTest2 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList();
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(100);
list.add(200);
list.add(100);
list.add(100);
//注意使用新式for循环在遍历集合的途中，如果你往集合中添加，或删除元素时，会报并发修改异常
//for (Integer integer : list) {
// if(integer.equals(200)){
// //list.remove(integer);
// // ConcurrentModificationException
// //list.add(10000);
// }
// //System.out.println(integer);
//}
for (int i = 0; i < list.size(); i++) {
if (list.get(i).equals(200)) {
//list.remove(integer);
// ConcurrentModificationException
list.add(10000);
}
}
System.out.println(list);
}
}
可变参数的概述和使用
A:可变参数概述: 定义方法的时候不知道该定义多少个参数
B:格式: 修饰符 返回值类型 方法名(数据类型… 变量名){}
C:注意事项：
a: 这里的变量其实是一个数组
b: 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
案例一：
public class MyTest {
public static void main(String[] args) {
int sum1 = add(1, 2);
int sum2 = add(1, 2, 3);
int sum3 = add(1, 2, 3, 4);
//可变参数: 数据类型 ... 参数名
//可变参数其实就是个数组
System.out.println(sum1);
System.out.println(sum2);
System.out.println(sum3);
}
//C:注意事项：
//a:这里的变量其实是一个数组
//b:如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
private static int add(double num, int... a) {
int sum = 0;
for (int i : a) {
sum += i;
}
return sum;
}
//private static int add(int i, int i1) {
// return 0;
//}
//
//private static int add(int i, int i1,int i2) {
// return 0;
//}
//
//private static int add(int i, int i1,int i2,int i3) {
// return 0;
//}
}
结果：
2
5
9
Arrays工具类的asList()方法的使用
A:案例演示: Arrays工具类的asList(T… t)方法的使用: 将数组转换成集合
注意事项: 得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)
只能获取元素(get)
案例一：
import java.util.Arrays;
import java.util.List;
public class MyTest3 {
public static void main(String[] args) {
List<Integer> integers = Arrays.asList(100, 200, 300, 400, 500, 600);
//当我们通过 Arrays.asList(100, 200, 300, 400, 500, 600);获取一个转换过来的集合
//那么这个集合的长度是固定的，你只能从里面取出元素用，而不能去增删元素
Integer integer = integers.get(0);
//integers.remove(0);
//integers.add(1);
// Object[] objects = integers.toArray();
}
}
案例二：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class MyTest2 {
public static void main(String[] args) {
//static <T > List < T >
// asList(T...a)
//把多个元素转换成集合
//
List<Integer> integers = Arrays.asList(100, 200, 300, 400, 500, 600);
int[] arr = {1, 2, 3};
Integer[] integers1 = {1, 2, 3};
Integer[] integers2 = {1, 2, 3};
Integer[] integers3 = {1, 2, 3};
//当我们使用 Arrays.asList()这个方法来转换集合的时候，如果我们传入一个或多个int[] 数组的时候，集合里面放的是数组的引用
List<int[]> ints = Arrays.asList(arr, new int[]{10}, new int[]{1, 6, 7});
System.out.println(ints);
//当我们使用 Arrays.asList()这个方法来转换集合的时候，如果我们传入一个Integer[] 数组，那么他会把数组的元素取出来放到集合中
List<Integer> integers99992 = Arrays.asList(integers1);
//当我们使用 Arrays.asList()这个方法来转换集合的时候，如果我们传入多个Integer[] 数组的时候，集合放的是每个Integer[] 数组的引用
List<Integer[]> integers9999 = Arrays.asList(integers1, integers2, integers3);
System.out.println(integers9999);
}
}
集合嵌套之ArrayList嵌套ArrayList
A:需求：
我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList
但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList。
而我现在有多个ArrayList。也要用集合存储，怎么办呢?
集合嵌套之ArrayList嵌套ArrayList
// 定义大的集合
ArrayList<ArrayList<Student>> allClassList = new ArrayList<ArrayList<Student>>() ;
// 创建每一个班的集合
ArrayList<Student> jcClassList = new ArrayList<Student>() ;
案例一：
//A:
//需求：
//我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList
//但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList。
//而我现在有多个ArrayList。也要用集合存储，怎么办呢 ?
// 集合嵌套之ArrayList嵌套ArrayList
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
import com.sun.media.sound.SoftTuning;
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
//A:
//需求：
//我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
//但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。
//而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢 ?
// 集合嵌套之ArrayList嵌套ArrayList
ArrayList<Student> javaList = new ArrayList<>();
javaList.add(new Student("张三1", 23));
javaList.add(new Student("张三2", 23));
javaList.add(new Student("张三3", 23));
ArrayList<Student> webList = new ArrayList<>();
webList.add(new Student("张三4", 23));
webList.add(new Student("张三5", 23));
webList.add(new Student("张三6", 23));
ArrayList<Student> linuxList = new ArrayList<>();
linuxList.add(new Student("张三7", 23));
linuxList.add(new Student("张三8", 23));
linuxList.add(new Student("张三9", 23));
//创建一个大的集合，大的集合放小的集合
ArrayList<ArrayList<Student>> maxList = new ArrayList<>();
maxList.add(javaList);
maxList.add(webList);
maxList.add(linuxList);
//
//遍历：普通for循环
for (int i = 0; i < maxList.size(); i++) {
ArrayList<Student> minList = maxList.get(i);
for (int j = 0; j < minList.size(); j++) {
Student student = minList.get(j);
System.out.println(student.getName() + "===" + student.getAge());
}
}
System.out.println("----------------------------------------------------------");
//新式for循环遍历
for (ArrayList<Student> students : maxList) {
for (Student student : students) {
System.out.println(student.getName() + "===" + student.getAge());
}
}
}
}
543
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
