java学习第二十天
1_集合框架(ArrayList存储字符串并遍历)(掌握)
JDK1.8新增的一个方法也能遍历集合
void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常
A:案例演示: ArrayList存储字符串并遍历
迭代器
普通for
2_集合框架(ArrayList存储自定义对象并遍历)(掌握)
A:案例演示: ArrayList存储自定义对象并遍历
迭代器
普通for
3_集合框架(Vector的特有功能)(掌握)
A:Vector类概述: Vector 类可以实现可增长的对象数组 , Vector 是同步的。
B:Vector类特有功能
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()
C:案例演示: Vector的特有功能演示
4_集合框架(LinkedList的特有功能)(掌握)
A:LinkedList类概述: List 接口的链接列表实现 , 此实现不是同步的
B:LinkedList类特有功能
public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()
C:案例演示
LinkedList的特有功能演示
5_集合框架(用LinkedList模拟栈数据结构的集合并测试)(理解)
A:案例演示: 需求：请用LinkedList模拟栈数据结构的集合，并测试
6_集合框架(去除ArrayList中重复字符串元素方式)(掌握)
A:案例演示
需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
思路：创建新集合方式
7_集合框架(去除ArrayList中重复自定义对象元素)(掌握)
A:案例演示
需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
B:注意事项
重写equals()方法
8_集合框架(泛型概述和基本使用)(理解)
A:泛型概述:
是一种把类型明确的工作
推迟到创建对象
或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。
B:泛型的格式:
<数据类型> 这里的数据类型只能是引用数据类型
C:泛型好处
(1): 把运行时期的问题提前到了编译期间
(2): 避免了强制类型转换
(3):优化了程序设计，解决了黄色警告线
注意：泛型只在编译期有效 但在运行期就擦除了
D:泛型基本使用
public static void main(String[] args) {
//泛型机制：是一种将数据类型明确工作，推迟到创建对象或调用方法时才去明确的一种机制。
//泛型的好处，可以避免向下转型，也可以提高程序的扩展性。
//泛型的语法 <类型> <类型,类型2,。。。。> 类型指的是引用类型
//泛型可以定义在类上 接口上 方法上
//泛型只在编译期有效，在运行期就擦除了。
//创建集合时，就要使用泛型
//没有使用泛型时,集合中可以存储多种引用数据类型
ArrayList list = new ArrayList();
list.add(new Integer(200));
list.add(new Integer(300));
list.add(new Integer(400));
list.add("abc");
list.add(3.14);
Object obj = list.get(0);
//得向下转型
Integer num= (Integer) obj;
int i = num.intValue();
System.out.println("=========================");
//创建集合时，我们用上泛型
//我明确了集合中只能存储String类型的数据
//(1):把运行时期的问题提前到了编译期间
ArrayList<String> list1 = new ArrayList<String>();
list1.add("abc");
//list1.add(200);
String s = list1.get(0); //避免了向下转型。
ArrayList<Integer> list2 = new ArrayList<>();
//list2.add("abc");
list2.add(200);
Integer integer = list2.get(0);
System.out.println(integer);
System.out.println("==================================");
//集合中可以存储多种多样的引用类型 你把泛型明确成Object
ArrayList<Object> list3 = new ArrayList();
list3.add(new Integer(200));
list3.add(new Integer(300));
list3.add(new Integer(400));
list3.add("abc");
list3.add(3.14);
list.add(new Object());
Object o = list.get(2);
//一般来说，不会在集合中存储多种引用数据类型 ，除非你有特殊需求
}
9_集合框架(ArrayList存储字符串并遍历泛型版)(理解)
A:案例演示: ArrayList存储字符串并遍历泛型版
public static void main(String[] args) {
/* ArrayList list = new ArrayList();
list.add(new Student("张三",23));
list.add(new Student("李四", 24));
list.add("abc");
Object obj = list.get(0);
Student student= (Student) obj;
String name = student.getName();*/
ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student("张三", 23));
list.add(new Student("李四", 24));
//避免向下转型
Student student = list.get(0);
//JDK1.5 之后才引入的泛型机制。
}
10_集合框架(ArrayList存储自定义对象并遍历泛型版)(理解)
A:案例演示: ArrayList存储自定义对象并遍历泛型版
11_集合框架(泛型的由来)(理解)
A:案例演示
ObjectTool
泛型的由来:通过Object转型问题引入
早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。
也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
public class MyClass {
private Object obj;
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
}
public class MyTest {
public static void main(String[] args) {
//好处就是提高扩展性，可以把任何引用类型设置进去
MyClass myClass = new MyClass();
myClass.setObj("abc");
MyClass myClass2 = new MyClass();
myClass2.setObj(100);
//不好之处，就是得向下转型
Object obj = myClass.getObj();
String s= (String) obj;
System.out.println(s.length());
Object obj1 = myClass2.getObj();
Integer num= (Integer) obj1;
System.out.println(num.intValue());
}
12_集合框架(泛型类的概述及使用)(理解)
A:泛型类概述: 把泛型定义在类上
B:定义格式: public class 类名<泛型类型1,…>
C:注意事项: 泛型类型必须是引用类型
D:案例演示: 泛型类的使用
- 泛型的应用之泛型类: 就是把泛型定义在类上
- 格式: public class 类名<数据类型 , ....> {}
13_集合框架(泛型方法的概述和使用)(理解)
A:泛型方法概述: 把泛型定义在方法上
B:定义格式: public <泛型类型> 返回类型 方法名(泛型类型 变量名)
C:案例演示: 泛型方法的使用
public class MyClass<T> {
T obj;
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
}
public static void main(String[] args) {
//泛型机制：是一种将数据类型明确工作，推迟到创建对象才去明确的一种机制。
MyClass<String> aClass = new MyClass<>();
aClass.setObj("abc");
String obj = aClass.getObj();
System.out.println(obj);
System.out.println("=====================");
MyClass<Integer> aClass2 = new MyClass<>();
aClass2.setObj(100);
Integer obj1 = aClass2.getObj();
System.out.println(obj1);
System.out.println("=====================");
// public class ArrayList<E>{
// }
ArrayList<String> strings = new ArrayList<>();
strings.add("abc");
}
14_集合框架(泛型接口的概述和使用)(理解)
A:泛型接口概述: 把泛型定义在接口上
B:定义格式: public interface 接口名<泛型类型>
C:案例演示: 泛型接口的使用
public interface MyInterface<R,P> {
public abstract R test(P p);
public abstract String show(Integer num);
}
//有一个具体的子类，在实现一个接口时，这个接口上有泛型，就可以明确接口上的泛型的具体类型
public class MySon implements MyInterface<Integer,String>{
@Override
public Integer test(String s) {
return null;
}
@Override
public String show(Integer num) {
return null;
}
}
public class MySon2 implements MyInterface<Double,String> {
@Override
public Double test(String s) {
return null;
}
@Override
public String show(Integer num) {
return null;
}
}
//子类在实现接口时，他没有急于去明确接口上的泛型，那么他自己就要定义成泛型类
public class MySon3<R,P> implements MyInterface<R,P> {
@Override
public R test(P p) {
return null;
}
@Override
public String show(Integer num) {
return null;
}
}
public static void main(String[] args) {
//接口上定义了泛型，那什么时候明确泛型的具体类型呢？在创建接口的子类对象时明确。
//匿名内部类
new MyInterface<Double,Integer>(){
@Override
public Double test(Integer integer) {
return null;
}
@Override
public String show(Integer num) {
return null;
}
};
new MyInterface<Character, Double>() {
@Override
public Character test(Double aDouble) {
return null;
}
@Override
public String show(Integer num) {
return null;
}
};
System.out.println("========================");
MySon mySon = new MySon();
Integer abc = mySon.test("abc");
MySon2 mySon2 = new MySon2();
Double abc1 = mySon2.test("abc");
System.out.println("==================");
MySon3<String, String> son3 = new MySon3<>();
String abc2 = son3.test("Abc");
}
15_集合框架(泛型高级之通配符)(理解)
A:泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E: 向下限定，E及其子类
C:? super E: 向上限定，E及其父类
D:案例演示: 泛型高级之通配符的基本使用
/**
* 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
*/
Collection<Object> col1 = new ArrayList<Object>() ;
Collection<Object> col2 = new ArrayList<Animal>() ;//报错
// ? 表示任意的数据类型
Collection<?> col5 = new ArrayList<Object>() ;
Collection<?> col6 = new ArrayList<Animal>() ;
// ? extends E : 向下限定 , ? 表示的是E或者E的子类
// Collection<? extends Animal> col9 = new ArrayList() ;//报错
Collection<? extends Animal> col10 = new ArrayList() ;
Collection<? extends Animal> col11 = new ArrayList() ;
// ? super E: 向上限定 , ? 表示的是E或者E的父类
Collection<? super Animal> col13 = new ArrayList<Object>() ;
Collection<? super Animal> col14 = new ArrayList<Animal>() ;
// Collection<? super Animal> col15 = new ArrayList() ;//报错
public static void main(String[] args) {
/* 接口 Collection<E>
List <E>, Set < E >,
ArrayList < E >*/
// ArrayList<E>
ArrayList<String> strings = new ArrayList<>();
/* boolean add (E e)
将指定的元素添加到此列表的尾部。*/
strings.add("Abc");
//泛型机制：是一种将数据类型明确工作，推迟到创建对象或调用方法时才去明确的一种机制。
ArrayList<Integer> list = new ArrayList<>();
list.add(100);
}
public static void main(String[] args) {
//? 泛型通配符
ArrayList<?> list = new ArrayList<Animal>();
ArrayList<?> list2 = new ArrayList<Dog>();
ArrayList<?> list3 = new ArrayList<Cat>();
System.out.println("=========================");
//向下限定 <? extends Animal> 是Animal本身 或者说他的子类
ArrayList<? extends Animal> list4 = new ArrayList<Animal>();
ArrayList<? extends Animal> list5= new ArrayList<Dog>();
ArrayList<? extends Animal> list6= new ArrayList<Cat>();
//报错
//ArrayList<? extends Animal> list57= new ArrayList<Object>();
System.out.println("=======================================");
//向上限定 <? super Animal> 是Animal本身 或者说的他的父类
ArrayList<? super Animal> list47= new ArrayList<Animal>();
ArrayList<? super Animal> list48 = new ArrayList<Object>();
//ArrayList<? super Animal> list49= new ArrayList<Dog>(); //报错
//ArrayList<? super Animal> list491 = new ArrayList<Cat>(); //报错
System.out.println("==========================");
ArrayList<Integer> integers = new ArrayList<>();
integers.add(100);
ArrayList<Object> integers2= new ArrayList<>();
integers2.add(200);
/*boolean addAll (Collection < ? extends E > c)
按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。*/
// boolean addAll (Collection < ? extends Integer > c) //向下限定
// integers.addAll(integers2); 报错，因为做了向下限定 ，你传进来的这个集合中的元素类型是Object类型,他不是Integer类型，或者说Integer的子类
}
}
class Animal{
}
class Dog extends Animal{
}
class Cat extends Animal{
}
16_集合框架(增强for的概述和使用)(掌握)
A:增强for概述
简化数组和Collection集合的遍历
B:格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
C:案例演示
数组，集合存储元素用增强for遍历
D:好处和注意事项
简化遍历
注意事项：增强for的目标要判断是否为null
注意新式for循环，你在迭代集合的途中，不能增删元素，会报并发修改异常
17_集合框架(ArrayList存储字符串并遍历增强for版)(掌握)
A:案例演示: ArrayList存储字符串并遍历增强for版
public static void main(String[] args) {
//JDK1.5之后提供了一种新的遍历方式，叫做增强for循环。
int[] arr={10,20,30};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("=========================");
//新式for循环来遍历数组
//for(容中的元素数据类型 当前遍历元素的变量名:容器名)
for(int num:arr){
System.out.println(num);
}
System.out.println("=========================");
ArrayList<Student> list = new ArrayList();
list.add(new Student("张三", 23));
list.add(new Student("李四", 24));
for(Student student:list){
System.out.println(student);
}
System.out.println("=============================");
ArrayList<String> list1 = new ArrayList<>();
list1.add("Abc");
list1.add("Abc");
list1.add("Abc");
list1.add("Abc");
list1.add("Abc");
//快速生成新式for循环 容器名.for 例如 list.for
for (String s : list1) {
System.out.println(s);
}
}
18_集合框架(ArrayList存储自定义对象并遍历增强for版)(掌握)
A:案例演示: ArrayList存储自定义对象并遍历增强for版
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
list1.add("BAbc");
list1.add("Abc");
list1.add("Abc");
list1.add("Abc");
list1.add("Abc");
//新式for循环其实底层用的是迭代器遍历的。
/* for (String s : list1) {
System.out.println(s);
}*/
//你用新式for循环在遍历途中，你不能去改变容器的长度,否则会出现并发修改异常。
//ConcurrentModificationException
/* for (String s : list1) {
if(s.startsWith("B")){
list1.remove(s);
}
// System.out.println(s);
}
*/
//我们一般用新式for循环，你只是为了遍历看，而不是在遍历途中去增删容器中的元素，因为你增删元素，就会报并发修改异常。
//如果你要在遍历途中增删集合中 的元素，你就使用普通for循环
for (int i = 0; i < list1.size(); i++) {
String s = list1.get(i);
if (s.startsWith("B")) {
list1.remove(s);
}
}
System.out.println(list1);
}
20_集合框架(可变参数的概述和使用)(理解)
A:可变参数概述: 定义方法的时候不知道该定义多少个参数
B:格式: 修饰符 返回值类型 方法名(数据类型… 变量名){}
C:注意事项：
a: 这里的变量其实是一个数组
b: 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
// 可变参数
public static int add(int... a){
// 定义一个累加变量
int sum = 0 ;
for(int s : a ){
sum += s ;
}
return sum;
}
public static void main(String[] args) {
int num = add1(1, 2);
int num2 = add1(1, 2, 3);
System.out.println(num);
System.out.println(num2);
}
/* private static int add1(int i, int i1, int i2) {
return i+i1+i2;
}
private static int add1(int i, int i1) {
return i+i1;
}*/
// 可变参数 参数数据类型 ... 参数名 一次可以接受多个实参
// 可变参数其实是个数组，把你传过来的多个参数放到数组中
private static int add1(int... i) {
//System.out.println("方法调用了");
//System.out.println(i.length);
int sum=0;
for (int ele : i) {
sum+=ele;
}
return sum;
}
//如果一个方法，定义了多个形参，可变参数一定是最后一个。
//语法报错，矛盾
/* private static int add2(double... i,double num) {
return 0;
}*/
//如果一个方法，定义了多个形参，可变参数一定是最后一个。
private static int add3(String num, double... i) {
return 0;
}
21_集合框架(Arrays工具类的asList()方法的使用)(掌握)
A:案例演示:
Arrays工具类的asList(T… t)方法的使用: 将数组转换成集合
注意事项: 得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove) 只能获取元素(get)
public static void main(String[] args) {
/* static <T> List < T >
asList(T...a)
返回一个受指定数组支持的固定大小的列表。*/
//把多个值，转换成一个集合
List<Integer> integers = Arrays.asList(10, 20, 20);
//把数组转换成一个集合
Integer[] integers1 = new Integer[]{200,300,400};
List<Integer> integers2 = Arrays.asList(integers1);
//把集合转换成数组
Object[] objects = integers.toArray();
}
22_集合框架(集合嵌套之ArrayList嵌套ArrayList)(掌握)
A:需求：
我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。
而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢?
集合嵌套之ArrayList嵌套ArrayList
// 定义大的集合
ArrayList<ArrayList<Student>> allClassList = new ArrayList<ArrayList<Student>>() ;
// 创建每一个班的集合
ArrayList<Student> jcClassList = new ArrayList<Student>() ;
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
