1.ArrayList存储自定义对象并遍历
此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。* ArrayList存储自定义对象并遍历
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("张三",23));
list.add(new Person("李四",24));
list.add(new Person("王五",25));
迭代器
//Iterator
for ( Iterator<Person> i = list.iterator(); i.hasNext(); ) {
Person p = i.next();
System.out.println(p);//输出的是每个对象；
System.out.println(p.getName()+","+p.getAge());//输出对象中的属性值
}
* 普通for
for(int i = 0;i < list.size();i++){
Person p = (Person)list.get(i);//强转
System.out.println(p);//输出每个对象
System.out.println(p.getName()+","+p.getAge());
}
2.Vector的特有功能
* A:Vector类概述
* B:Vector类特有功能
* public void addElement(E obj)//添加一个元素
* public E elementAt(int index)//返回指定索引处的元素
* public Enumeration elements()//迭代
* C:案例演示
* Vector的特有功能演示
* Vector v = new Vector();
v.addElement("my");
v.addElement("girl");
Object obj = v.elementAt(1);
System.out.println(obj);//girl
for(Enumeration e = v.elements();e.hasMoreElements();){
System.out.println(e.nextElement());
}
3.LinkedList的特有功能
* A:LinkedList类概述* 底层数据结构是链表，查找慢，删除快
* B:LinkedList类特有功能
* public void addFirst(E e)及addLast(E e)//在头添加，在尾添加
* public E getFirst()及getLast()//得到头元素，得到尾元素
* public E removeFirst()及public E removeLast()//删除头元素，删除尾元素
* LinkedList list = new LinkedList();
list.addFirst("1");
list.addFirst("2");
System.out.println(list);//[2,1]
list.addLast("3");
list.addLast("4");
System.out.println(list);//[2,1,3,4]
Object obj = list.getFirst();
System.out.println(obj);//
Object obj1 = list.getLast();
System.out.println(obj1);//
Object obj2 = list.removeFirst();
System.out.println(obj2);//
System.out.println(list);
Object obj3 = list.removeLast();
System.out.println(obj3);//
System.out.println(list);//[1,3]
4.去除ArrayList中重复字符串元素方式
需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
思路：创建新集合方式
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("a");
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("c");
ArrayList list2 = getSingle(list);
System.out.println(list2);
}
public static ArrayList getSingle(ArrayList list){
ArrayList list1 = new ArrayList();
for(Iterator i = list.iterator();i.hasNext();){
String str = (String)i.next();
if(!list1.contains(str)){
list1.add(str);
}
}
return list1;
}
需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Person("张三",23));
list.add(new Person("张三",23));
list.add(new Person("李四",24));
list.add(new Person("李四",24));
list.add(new Person("王五",25));
list.add(new Person("王五",25));
ArrayList list2 = getSingle1(list);
System.out.println(list2);//重写equals 方法
}
public static ArrayList getSingle1(ArrayList list){
ArrayList list1 = new ArrayList();
for(Iterator i = list.iterator();i.hasNext();){
Person p = (Person)i.next();
if(!list1.contains(p)){
list1.add(p);
System.out.println(p.getName()+","+p.getAge());
}
}
return list1;
}
* B:注意事项
重写equals()方法的
@Override
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
* contains() 和remove() 方法底层都是依赖于equals()方法，
* 如果没有重写equals()方法，比较的都是地址值。
5.用LinkedList模拟栈数据结构的集合并测试
需求：请用LinkedList模拟栈数据结构的集合，并测试
1.LinkedList list = new LinkedList();
list.addLast("B");//从结尾添加元素，
list.addLast("M");
list.addLast("W");
System.out.println(list);
while(!list.isEmpty()){
list.removeLast();//删除结尾的元素
System.out.println(list);
}
System.out.println(list);
2.测试类：
LinkedList list = new LinkedList();
list.addFirst("B");//从开头添加元素，
list.addFirst("M");
list.addFirst("W");
System.out.println(list);
while(!list.isEmpty()){
list.removeFirst();//删除结尾的元素
System.out.println(list);
}
System.out.println(list);
运行类：
public class Stack {
private LinkedList list = new LinkedList();
//进栈，只需要把元素放进去即可，不需要任何返回类型；
//返回值类型为：void ，参数列表：Object obj--传入任意一个数
public void in(Object obj){
list.addFirst(obj);
}
//出栈，返回的是一个数，类型为：Object ；参数无。
public Object out(){
return list.removeFirst);
}
//判空方法。返回值类型为boolean。
public boolean isEmpty(){
return list.isEmpty();
}
}
6.泛型概述和基本使用
* A:泛型概述 <T>，JDK1.5出现的
* <> 是泛型，里面放的是引用数据类型，因为集合只能存引用数据类型。
* <> 前面加 后面不加 是JDK1.7版本出现，叫做菱形泛型
* B:泛型好处
* 把运行期的错误转换到运行期、不用强转
* C:泛型基本使用
7.ArrayList存储字符串并遍历泛型版
ArrayList<String> list = new ArrayList<>();
list.add("MY");
list.add("B");
list.add("M");
list.add("W");
//不使用泛型
for(Iterator i = list.iterator();i.hasNext();){
String s = (String)i.next();//此处的i.next()接收的是Object类型
System.out.println(s);
}
/*使用泛型，不用强转类型
for(Iterator<String> i = list.iterator();i.hasNext();){
String s = i.next();//此处的i.next()接收的是String类型。
System.out.println(s);
//System.out.println(i.next());//俩句可以换成一句。
}*/
ArrayList存储自定义对象并遍历泛型版
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("张三",23));//此处添加的.add()方法，提示的只接受Person类的对象。
list.add(new Person("李四",24));
list.add(new Person("王五",25));
//非泛型。需要强转。
for (Iterator i = list.iterator(); i.hasNext();) {
Person p = (Person) i.next();
System.out.println(p.getName()+","+p.getAge());
}
/* 泛型的情况。
for (Iterator<Person> i = list.iterator(); i.hasNext();) {
Person p = i.next();//此处直接得到的就是person中的对象。
System.out.println(p.getName()+","+p.getAge());
}*/
8.泛型的由来、泛型类的概述及使用
* 泛型的由来:通过Object转型问题引入
* 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
* A:泛型类概述
* 把泛型定义在类上
* B:定义格式
* public class 类名<泛型类型1,…>
* public class Tool<W>{}
* 泛型类型在创建对象时才有值。
* C:注意事项
* 泛型类型必须是引用类型
9.泛型方法的概述和使用
* A:泛型方法概述
* 把泛型定义在方法上
* 非静态的方法：public void show(W w){}
* 静态的方法：public static <W>返回值类型 方法名(W w){},静态的方法直接可以用类名.调用，优于对象的创建。
* B:定义格式
* public <泛型类型> 返回类型 方法名(泛型类型 变量名)
10.泛型接口的概述和使用
* A:泛型接口概述
* 把泛型定义在接口上
* B:定义格式
* public interface 接口名<泛型类型>
* interface Inter<T>{
* public abstract void show();
* }
* 1.class Demo implements Inter<String>{//建议开发用,实现接口，已经确定是什么类型了。
* public void show(String s){
* System.out.println(s);
* }
* }
* 2.class Demo<T> implements Inter<T>{//Demo创建对象才实现T
* public void show(T t){
*
* }
* }
11.泛型高级之通配符
* A:泛型通配符<?>//不确定谁来用
* 任意类型，如果没有明确，那么就是Object以及任意的Java类了
* B:? extends E
* 向下限定，E及其子类
* 可以添加E类型以及E的子类型，E是上边界（固定上边界）
* C:? super E
* 向上限定，E及其父类
12.增强for的概述和使用
* A:增强for概述
* 底层就是迭代器实现
* 简化数组和Collection集合的遍历
* B:格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
for（临时变量：容器名）{
输出临时变量；
}
ArrayList存储字符串并遍历增强for版
ArrayList<String> list = new ArrayList<>();
list.add("MY");
list.add("little");
list.add("girl");
for(String str : list){
System.out.println(str);
}
ArrayList存储自定义对象并遍历增强for版
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("张三",23));
list.add(new Person("李四",24));
list.add(new Person("王五",25));
for (Person p : list) {
//System.out.println(p);
System.out.println(p.getName()+","+p.getAge());
}
13.静态导入的概述和使用
* A:静态导入概述
* 导入的是静态方法，只要是静态方法都能用静态导入，开发严重不推荐，
* B:格式：
* import static 包名….类名.方法名;
* 可以直接导入到方法的级别
* C:注意事项
* 方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。
14.可变参数的概述和使用
* A:可变参数概述
* 其实就是一个可变的数组
* 定义方法的时候不知道该定义多少个参数
* B:格式
* 修饰符 返回值类型 方法名(数据类型… 变量名){}
* C:注意事项：
* 这里的变量其实是一个数组
* 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
15.Arrays工具类的asList()方法的使用
* A:案例演示
* Arrays工具类的asList()方法的使用
* 将数组转换成集合，转换后的集合不能添加删除里面的元素，
* 必须是引用数据类型的数组，否则会将整个数组当成一个对象，
集合嵌套之ArrayList嵌套ArrayList
ArrayList<ArrayList<Person>> list = new ArrayList<>();
ArrayList<Person> list1 = new ArrayList<>();
list1.add(new Person("张三",23));
list1.add(new Person("李四",24));
list1.add(new Person("王五",25));
ArrayList<Person> list2 = new ArrayList<>();
list2.add(new Person("小张",12));
list2.add(new Person("小李",11));
list2.add(new Person("小王",13));
list.add(list1);//添加集合
list.add(list2);
for(ArrayList<Person>li : list){
for(Person p : li){
System.out.println(p);
}
}