集合的关系图解
ArrayList的概述及使用
ArrayList的概述： ArrayList是List的子类 ，而List又是Collection的子类ArrayList的成员方法 因为ArrayList继承自List，而List又继承自Collection，所以父类未被私有的成员方法ArrayList均可使用ArrayList的案例：
请编写程序，将自定义对象存储到ArrayList集合，使用泛型并遍历
a) 使用迭代器遍历
b) 使用列表迭代器遍历
c) 使用size()和get()方法遍历
d) 使用增强for遍历
package org.westos.demo2;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Demo {
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student("张三", 23));
list.add(new Student("李四", 22));
list.add(new Student("王五", 25));
Iterator<Student> iterator = list.iterator();
System.out.println("迭代器进行遍历");
while (iterator.hasNext()) {
Student next = iterator.next();
System.out.println(next);
}
System.out.println("列表迭代器进行遍历");
ListIterator<Student> studentListIterator = list.listIterator();
while (studentListIterator.hasNext()) {
Student next = studentListIterator.next();
System.out.println(next);
}
System.out.println("size()和get()方法进行遍历");
for (int i = 0; i < list.size(); i++) {
Student student = list.get(i);
System.out.println(student);
}
System.out.println("使用增强for()循环进行遍历");
for (Student student : list) {
System.out.println(student);
}
}
}
class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
Vector的概述及使用方法
Vector类概述： Vector 类可以实现可增长的对象数组 , Vector 是同步的。Vector类特有功能： public void addElement(E obj) 给Vector集合添加元素 public E elementAt(int index) 查找某一元素的索引 public boolean removeElement(Object obj) 删除集合中的某个元素 public void removeElementAt(int index) 删除集合中指定索引处的元素 public void setElementAt(E obj, int index) 用指定元素替换指定索引处的元素 public Enumeration elements() 创建一个迭代器案例演示
请编写程序，将自定义对象存储到Vector集合，使用泛型并遍历
a) 使用迭代器遍历
b) 使用Vector特有的迭代器遍历
c) 使用size()和get()方法遍历
d) 使用增强for遍历
package org.westos.demo2;
import java.util.*;
public class Demo {
public static void main(String[] args) {
Vector<Student> list = new Vector<>();
list.add(new Student("张三", 23));
list.add(new Student("李四", 22));
list.add(new Student("王五", 25));
Iterator<Student> iterator = list.iterator();
System.out.println("迭代器进行遍历");
while (iterator.hasNext()) {
Student next = iterator.next();
System.out.println(next);
}
System.out.println("Vector特有的迭代器进行遍历");
Enumeration<Student> elements = list.elements();
while (elements.hasMoreElements()) {
Student next = elements.nextElement();
System.out.println(next);
}
System.out.println("size()和get()方法进行遍历");
for (int i = 0; i < list.size(); i++) {
Student student = list.get(i);
System.out.println(student);
}
System.out.println("使用增强for()循环进行遍历");
for (Student student : list) {
System.out.println(student);
}
}
}
class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
LinkedList的概述及使用方法
LinkedList类概述： List 接口的链接列表实现 , 此实现不是同步的LinkedList类特有功能： public void addFirst(E e) 给集合最顶层添加元素 public void addLast(E e) 给集合的末尾添加元素 public E getFirst() 获取集合的首位元素 public E getLast() 获取集合的末尾元素 public E removeFirst() 删除集合的首位元素 public E removeLast() 删除集合的末尾元素案例演示：
请编写程序，将自定义对象存储到LinkedList集合，使用泛型并遍历
a) 使用迭代器遍历
b) 使用列表迭代器遍历
c) 使用size()和get()方法遍历
d) 使用增强for遍历
package org.westos.demo2;
import java.util.*;
public class Demo {
public static void main(String[] args) {
LinkedList<Student> list = new LinkedList<>();
list.add(new Student("张三", 23));
list.add(new Student("李四", 22));
list.add(new Student("王五", 25));
Iterator<Student> iterator = list.iterator();
System.out.println("迭代器进行遍历");
while (iterator.hasNext()) {
Student next = iterator.next();
System.out.println(next);
}
System.out.println("列表迭代器进行遍历");
ListIterator<Student> studentListIterator = list.listIterator();
while (studentListIterator.hasNext()) {
Student next = studentListIterator.next();
System.out.println(next);
}
System.out.println("size()和get()方法进行遍历");
for (int i = 0; i < list.size(); i++) {
Student student = list.get(i);
System.out.println(student);
}
System.out.println("使用增强for()循环进行遍历");
for (Student student : list) {
System.out.println(student);
}
}
}
class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
泛型概述和基本使用
泛型概述： 是一种把类型明确的工作，推迟到创建对象，或者调用方法的时候才去明确的特殊的类型。 参数化类型，把类型当作参数一样的传递。泛型的格式： <数据类型> 这里的数据类型只能是引用数据类型注意事项: 泛型类型必须是引用类型泛型好处： (1): 把运行时期的问题提前到了编译期间 (2): 避免了强制类型转换 (3):优化了程序设计，解决了黄色警告线 注意：泛型只在编译期有效 但在运行期就擦除了泛型类的案例演示： 以上的三个集合案例均使用了泛型
泛型方法的案例，并可以返回泛型类型
public class Demo {
public <T> T show(T a) {
System.out.println(a);
return a;
}
}
泛型接口的演示
package org.westos.demo4;
import java.util.Collection;
public interface MyInterface<T,U,R> { //泛型接口
public R show(T t,U u);
}
//泛型接口上的泛型，什么时候名曲，你可以在子类里面去明确
class MyDemo implements MyInterface<String,Integer,Integer>{
@Override
public Integer show(String s, Integer integer) {
return null;
}
}
泛型高级之通配符
泛型高级的表达方式： （1）:泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了 （2）:? extends E ： 泛型的向下限定，E及其子类 （3）:? super E ： 泛型的向上限定，E及其父类案例演示：
class Animal {}
class Dog extends Animal{}
class Cat extends Animal{}
class GenericDemo {
public static void main(String[] args) {
Collection<Object> c = new ArrayList<Object>();
Collection<Animal> c1 = new ArrayList<Animal>();
Collection<? extends Animal> c5 = new ArrayList<Animal>();
Collection<? extends Animal> c6 = new ArrayList<Dog>();
Collection<? extends Animal> c7 = new ArrayList<Cat>();
Collection<? super Animal> c8 = new ArrayList<Object>();
Collection<? super Animal> c9 = new ArrayList<Animal>();
}
}
增强for的概述和使用
增强for概述： 简化数组和Collection集合的遍历格式： for(元素数据类型 变量 : 数组或者Collection集合) { 使用变量即可，该变量就是元素 }好处和注意事项： 简化遍历 注意事项：增强for的目标要判断是否为null案例演示： 以上的三个集合的案例均使用了增强for()循环 再来一个数组增强for()循环的案例演示
public class MyTest {
public static void main(String[] args) {
int[] arr={20,40,50,60};
for(int ele:arr){
System.out.println(ele);
}
}
}
可变参数的概述和使用
可变参数概述： 定义方法的时候不知道该定义多少个参数格式： 修饰符 返回值类型 方法名(数据类型… 变量名){}注意事项： a: 这里的变量其实是一个数组 b: 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个案例演示：
请编写程序，完成N个数 相加的功能，并测试
package org.westos.demo2;
public class Demo2 {
public static void main(String[] args) {
Integer sum = sum(1, 2, 3,4);
System.out.println(sum);
}
public static Integer sum(Integer ...a){
int sum=0;
for (int i = 0; i < a.length; i++) {
sum+=a[i];
}
return sum;
}
}
Arrays工具类的asList()方法的使用
Arrays工具类的asList(T… t)方法的使用: 将数组转换成集合注意事项: 得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)，只能获取元素(get)案例演示：
package org.westos.demo2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class MyTest2 {
public static void main(String[] args) {
//创建一个数组，遍历集合取出元素放到数组里面
int[] arr = {20, 40, 50, 60};
int[] arr2 = {20, 40, 50, 60};
int[] arr3 = {20, 40, 50, 60};
//把数组转换成集合
List<int[]> ints = Arrays.asList(arr1,arr2,arr3);
int[] ints1 = ints.get(0);
//注意事项：通过asList转换过来的集合，该集合就不能再次添加元素或删除元素
//只能获取元素来用
//把数组转换成集合
//如果你给的这个数组，是一个元素是基本类型的数组，他是把这个数组对象装到集合里面
List<int[]> int3 = Arrays.asList(arr3);
//如果你给的是一个引用类型的数组，他是把数组的元素取出来，放到集合中
Integer[] integers2 = {10, 20, 30};
List<Integer> integers1 = Arrays.asList(integers2);
System.out.println(integers1);
//如果你传了两个以上的对象数组，那么他是把两个对象数组，存到集合中
List<Integer[]> integers3 = Arrays.asList(integers2, integers2);
}
}
