目录
对象数组的概述及使用
案例演示
我有五个学生，请把他们存储到数组中，并遍历数组，获取到每一个学生的信息
Student[] arr = new Student[5];
arr[0] = new Student("张三"，23）；
arr[1] = new Student("李四"，23）；
arr[2] = new Student("王五"，23）；
arr[3] = new Student("赵六"，23）；
arr[4] = new Student("马哥"，23）；
import com.bean.Student;
public class demo1 {
public static void main(String[] args) {
Student[] arr =new Student[5];
arr[0] = new Student("张三",23);
arr[1] = new Student("李四",24);
arr[2] = new Student("王五",25);
arr[3] = new Student("赵六",26);
arr[4] = new Student("马哥",27);
for(int i =0;i<arr.length;i++) {
System.out.println(arr[i]);
}
/* com.bean.Student@6a5fc7f7
com.bean.Student@3b6eb2ec
com.bean.Student@1e643faf
com.bean.Student@6e8dacdf
com.bean.Student@7a79be86 //打印每个对象的引用默认调用toString()方法没有重写
*/
}
}
内存图：
集合
集合的由来
数组的长度是固定的，当添加的元素超过了数组的长度时需要对数组重新定义，太麻烦，java内部给我们提供了集合类，能存储任意对象，长度是可以改变的，随着元素的增加而增加，随着元素的减少而减少
数组和集合的区别：
1.数组既可以存储基本数据类型也可以存储引用数据类型
集合只能存储引用数据类型
2.数组的长度是固定的，不能自动增长
集合的长度是可变的，根据元素的增加而增长
数组和集合分别在什么时候用？
元素个数是固定的推荐用数组
元素个数不是固定的推荐用集合
集合继承体系图
集合的基本功能测试
boolean add(E e)//添加
boolean remove(Object o) //删除指定元素，只能删除一个元素
void clear() //清空集合
boolean contains(Object o) //是否包含
boolean isEmpty() //是否为空
int size()//获取元素的个数
注意：
collectionXxx.java使用了未经检查或不安全的操作
要了解详细信息，请使用-Xlint：unchecked重新编译
java编译器认为该程序存在隐患
（这不是编译失败，所以可以先不用理会，泛型部分会牵扯到）
import java.util.ArrayList;
import java.util.Collection;
import com.bean.Student;
@SuppressWarnings("rawtypes")
public class cl {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
//demo11();
//demo22();
}
public static void demo22() {
Collection c = new ArrayList();
c.add("a");
c.add("b");
c.add("c");
c.remove("b"); //删除指定元素,但是只能删除一个
System.out.println(c);
}
public static void demo11() {
Collection c = new ArrayList();
boolean b1 = c.add("abc");
boolean b2 = c.add(true); //自动装箱new Boolean(true)
boolean b3 = c.add(100);
boolean b4 = c.add(new Student("张三",23));
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);
//在list集合中一直都会返回true在set集合里面存储重复才会返回false
//ArrayList的父类的父类重写了toString方法，所以在打印的时候输出的结果不是Object类中的toString方法
System.out.println(c); //[abc, true, 100, Student [name=张三, age=23]]
}
}
集合的遍历之集合转数组遍历
import java.util.ArrayList;
import java.util.Collection;
import com.bean.Student;
@SuppressWarnings("rawtypes")
public class demo3_ {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
// TODO Auto-generated method stub
//demo1()
//存自定义对象
Collection c = new ArrayList();
c.add(new Student("张三",23));
c.add(new Student("李四",24));
c.add(new Student("王五",25));
c.add(new Student("赵六",26));
Object[] arr = c.toArray();
for(int i =0 ;i<arr.length;i++) {
// System.out.println(arr[i]);
Student s =(Student)arr[i]; //向下转型
System.out.println(s.getName()+s.getAge());
}
}
@SuppressWarnings("unchecked")
public static void demo1() {
Collection c = new ArrayList();
c.add("a");
c.add("b");
c.add("c");
c.add("d");
Object[] arr = c.toArray();
for(int i =0 ;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
带all的功能测试
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)
import java.util.ArrayList;
import java.util.Collection;
public class demo4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//demo111();
//demo222();
//demo333();
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
Collection c2 = new ArrayList();
c2.add("a");
c2.add("b");
//取交集，如果调用的集合改变就返回true，如果调用的集合不变就返回false
boolean b = c1.retainAll(c2);
System.out.println(b);
System.out.println(c1);
}
public static void demo333() {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
Collection c2 = new ArrayList();
c2.add("a");
c2.add("b");
boolean b = c1.containsAll(c2); //c2中可以有重复元素，但是不可以有不存在的元素
System.out.println(b);
}
public static void demo222() {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
Collection c2 = new ArrayList();
c2.add("a");
c2.add("b");
boolean b = c1.removeAll(c2); //删除c2与c1元素中的交集
System.out.println(b);
System.out.println(c1);
}
public static void demo111() {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
Collection c2 = new ArrayList();
c2.add("a");
c2.add("b");
c2.add("c");
c1.addAll(c2); //将c2添加到c1中，每一个元素都添加进去
c1.add(c2);//将c2看成一个对象添加到c1中
System.out.println(c1);
}
}
集合的遍历之迭代器遍历
集合是用来存储元素的，存储的元素需要查看，那么就需要迭代器遍历
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class demo5 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Collection c = new ArrayList();
c.add("a");
c.add("b");
c.add("c");
Iterator it = c.iterator();
//对集合中的元素迭代
while(it.hasNext())
System.out.println(it.next());
}
}
迭代器的原理及源码解析
原理：迭代器是对集合进行遍历，而每一个集合内部的存储结构都是不同的，所以每一个集合存和取都是不一样的，那么就需要在每一个类中定义hasNext()和next()方法这样做是可以的，但是会使整个集合体系过于臃肿，迭代器是将这样的方法向上抽取出接口，然后每个类的内部定义自己的迭代方法，这样做的好处有两个，第一是规定了整个集合体系的遍历方式都是hasNext()和next()方法，第二，代码有底层内部实现，使用者不管怎么实现，直接使用即可
迭代器源码解析
在eclipse中ctrl+shift+t找到ArrayList类
crtl+O查找iterator()方法
查看返回值类型是new Itr(),说明Itr这个类实现Iterator接口
查找Itr这个内部类，发现重写了Iterator中所有抽象方法
List集合特有的功能概述和测试
void add(int index,E element)
E remove(int index)
E get(int index)
E set(int index,E element)
import java.util.ArrayList;
import java.util.List;
public class demo6 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//demo1111()
//demo2222()
}
public static void demo2222() {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Object obj =list.remove(1); //将被删除的元素返回
System.out.println(obj);
System.out.println(list);
}
public static void demo1111() {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add(1,"e"); //但是索引不可以越界，index<=size&&index>=0都不会异常
System.out.println(list);
}
}
list集合中存储学生 对象并遍历
import java.util.ArrayList;
import java.util.List;
import com.bean.Student;
public class test {
public static void main(String[] args) {
// TODO Auto-generated method stub
List list = new ArrayList();
list.add(new Student("张三",23));
list.add(new Student("李四",24));
list.add(new Student("王五",25));
list.add(new Student("赵六",26));
for(int i=0;i<list.size();i++) {
Student s = (Student)list.get(i);
System.out.println(s.getName()+s.getAge());
// System.out.println(list.get(i)); //通过索引获取每一个元素
}
}
}并发修改异常产生的原因及解决方案
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import com.bean.Student;
public class demo7 {
public static void main(String[] args) {
// TODO Auto-generated method stub
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("world");
list.add(new Student("张三",23));
/* Iterator it = list.iterator();
while(it.hasNext()) {
Object obj = it.next();
if(obj=="world") {
list.add("javaee"); //遍历的同时增加，并发修改ConcurrentModificationException
}
}*/
ListIterator lit = list.listIterator();
while(lit.hasNext()) {
Object obj = lit.next();
if(obj == "world") {
lit.add("javaee");
}
}
System.out.println(list);
}
}
listiterator
boolean hasNext()是否有下一个
boolean hasPrevious()是否有前一个
Object next()返回下一个元素
Object previous()返回上一个元素
想要实行找前一个可以用指针得先遍历到后面
Vector的特有功能
import java.util.Enumeration;
import java.util.Vector;
public class demo8 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Vector v= new Vector();
v.addElement("a");
v.addElement("b");
v.addElement("c");
v.addElement("d");
v.addElement("e");
Enumeration en = v.elements(); //获取枚举
while(en.hasMoreElements()) {
System.out.println(en.nextElement());
}
}
}
list三个子类的特点
ArraylList:
底层数据结构是数组，查询快，增删慢；
线程不安全，效率高；
Vector：
底层数据结构是数组，查询快，增删慢；
线程安全，效率低
Vector相对ArrayList查询慢（线程安全的
Vector相对Link List增删慢（数据结构
LinkList：
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高
Vector和ArrayList的区别
Vector是线程安全的，效率低ArrayList相反，但都是数组实现的
ArrayList和LinkList的区别
ArrayList底层是数组，查询快，增删慢，LinkList底层是链表与之相反。但是他们线程都是安全的
**查询多用ArrayList增删多用LinkList,都多用ArrayList
1667
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
