对象数组
存的是一个对象
import java.util.Arrays;
public class MyTest {
public static void main(String[] args) {
//需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。
// 学生：Student
// 成员变量：name,age
// 构造方法：无参,带参
// 成员方法：getXxx()/setXxx()
Student s1 = new Student("苏沅湘", 20);
Student s2 = new Student("崔季宣", 20);
Student s3 = new Student("周颖", 18);
//把要把上面三个学生对象存储起来
//数组，字符串缓冲区
//对象数组
Student[] students={s1,s2,s3};
for (int i = 0; i < students.length; i++) {
Student student = students[i];
System.out.println(student.getName()+"==="+student.getAge());
}
//删掉数组中的第三个元素
Student[] students1 = Arrays.copyOf(students, 2);
System.out.println(Arrays.toString(students1));
}
}
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;
}
}集合
数组作为容器：可以存储多种多样的类型，但是数组作为容器，增删数组中的元素是很不方便的。
那Java为了我们更方便的去操作（增删改查）容器中的元素，给我们提供了另外一个容器，叫做集合
数组和集合的区别
(1): 长度区别:
数组的长度是固定的而集合的长度是可变的
(2): 存储数据类型的区别:
数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
(3): 内容区别:
数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素Collection集合
Collection的功能概述
a:添加功能
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
b:删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素
如果没有交集元素 则删除失败 返回false
c:判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
比如：1，2，3 containsAll 12=true 1,2,3 containsAll 2,3,4=false
boolean isEmpty()：判断集合是否为空
d:获取功能
Iterator<E> iterator()(重点)
e:长度功能
int size():元素的个数
f:交集功能
//例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
g:把集合转换为数组
Object[] toArray()功能的演示
import java.util.ArrayList;
import java.util.Collection;
public class MyTest {
public static void main(String[] args) {
// Collection 接口 是个单列集合的父类
//多态
Collection collection = new ArrayList();
//往集合中添加元素，返回值的意思是 是否添加成功
boolean b = collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
System.out.println(collection);
}
}import jdk.management.resource.internal.inst.SocketInputStreamRMHooks;
import java.util.ArrayList;
import java.util.Collection;
public class MyTest2 {
public static void main(String[] args) {
//addAll() 把两个集合中 的元素放到一个集合中
Collection collection = new ArrayList();
//往集合中添加元素，返回值的意思是 是否添加成功
boolean b = collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
Collection collection1 = new ArrayList();
collection1.add(100); //自动装箱
collection1.add(Integer.valueOf(20));
collection1.add(300);
collection1.add(400);
boolean b1 = collection.addAll(collection1);
System.out.println(collection);
System.out.println(collection1);
}
}import java.util.ArrayList;
import java.util.Collection;
public class MyTest {
public static void main(String[] args) {
Collection collection1 = new ArrayList();
collection1.add(100); //自动装箱
collection1.add(Integer.valueOf(20));
collection1.add(300);
collection1.add(400);
//删掉集合中的元素
boolean b = collection1.remove(400);
System.out.println(collection1);
//清空集合中集合中的元素
collection1.clear();
System.out.println(collection1);
}
}import java.util.ArrayList;
import java.util.Collection;
public class MyTest2 {
public static void main(String[] args) {
Collection collection1 = new ArrayList();
collection1.add(1000); //自动装箱
collection1.add(2000);
collection1.add(3000);
collection1.add(4000);
collection1.add(4000);
collection1.add(500);
Collection collection2 = new ArrayList();
collection2.add(100); //自动装箱
collection2.add(200);
collection2.add(300);
collection2.add(400);
//A集合removeAll(B集合) A 集合会移除掉两个集合的交集元素，如果移除了返回true，没有交集元素返回false
boolean b = collection1.removeAll(collection2);
System.out.println(b);
System.out.println(collection1);
System.out.println(collection2);
}
}import java.util.ArrayList;
import java.util.Collection;
public class MyTest3 {
public static void main(String[] args) {
//与判断相关的方法
Collection collection1 = new ArrayList();
collection1.add(1000); //自动装箱
collection1.add(2000);
collection1.add(3000);
collection1.add(4000);
collection1.add(4000);
collection1.add(500);
//判断集合中是否有这个元素
boolean b = collection1.contains(5000);
System.out.println(b);
}
}import jdk.management.resource.internal.inst.SocketOutputStreamRMHooks;
import java.util.ArrayList;
import java.util.Collection;
public class MyTest4 {
public static void main(String[] args) {
Collection collection1 = new ArrayList();
collection1.add(100); //自动装箱
collection1.add(200);
collection1.add(300);
collection1.add(400);
collection1.add(4000);
collection1.add(500);
Collection collection2 = new ArrayList();
collection2.add(100); //自动装箱
collection2.add(200);
collection2.add(300);
collection2.add(400);
collection2.add(600);
// [1,2,3]containsAll([1,2,4]) //false
// [1, 2, 3,4]containsAll([1, 2, 4]) //true
boolean b = collection1.containsAll(collection2);
System.out.println(b);
}
}import java.util.ArrayList;
import java.util.Collection;
public static void main(String[] args) {
Collection collection1 = new ArrayList();
collection1.add(1000); //自动装箱
collection1.add(2000);
collection1.add(3000);
collection1.add(4000);
collection1.add(4000);
collection1.add(500);
//获取集合的长度
int size = collection1.size();
System.out.println(size);
collection1.clear();
//判断一个集合是否为空
boolean empty = collection1.isEmpty();
System.out.println(empty);
// "".isEmpty();
}
}迭代器
使用迭代器对集合进行遍历
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class MyTest {
public static void main(String[] args) {
Collection collection1 = new ArrayList();
collection1.add(1000); //自动装箱
collection1.add(2000);
collection1.add(3000);
collection1.add(4000);
collection1.add(4000);
collection1.add(500);
//遍历Collection集合需要获取一个迭代器
//对 collection 进行迭代的迭代器
/* boolean hasNext ()
如果仍有元素可以迭代，则返回 true。
E next ()
返回迭代的下一个元素。*/
// 接口 Iterator<E >
Iterator iterator = collection1.iterator();
//java.util.ArrayList$Itr @ 1 b6d3586
Object next = iterator.next();//手动移动
System.out.println(next);
System.out.println(iterator);
while (iterator.hasNext()){
Object obj= iterator.next();
System.out.println(obj);
}
}
}List集合
List集合的特有功能概述
void add(int index,E element): 在指定索引处添加元素
E remove(int index):移除指定索引处的元素 返回的是移除的元素
E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素功能演示
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
public class MyTest {
public static void main(String[] args) {
Collection collection1 = new ArrayList();
collection1.add(1000); //自动装箱
collection1.add(2000);
collection1.add(3000);
collection1.add(4000);
collection1.add(4000);
collection1.add(500);
//把一个集合转换成数组
//toArray();把一个集合转换成数组
Object[] objects = collection1.toArray();
//遍历途中可以对元素进行向下转型
for (int i = 0; i < objects.length; i++) {
Integer object = (Integer) objects[i];
System.out.println(object.intValue());
}
}
}import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class MyTest2 {
public static void main(String[] rgs) {
List list = new ArrayList();
list.add(1000); //自动装箱
list.add(2000);
list.add(3000);
list.add(4000);
list.add(4000);
list.add(500);
//在指定索引处添加元素
list.add(0,20000);
System.out.println(list);
//根据索引获取元素
Object o = list.get(list.size() - 1);
System.out.println(o);
//根据起始索引，终止索引，截取一段元素放到新集合中
List list1 = list.subList(2, 4);
System.out.println(list1);
list.set(list.size()-1,5000); //根据索引，修改元素
System.out.println(list);
list.remove(2);
list.remove(Integer.valueOf(2000)); //假如是Integer类型，我要删除的时候，区分不出来 索引和对象了
//如果你要根据元素删，你就把元素手动包装一下
System.out.println(list);
}
}List有自己专用的迭代器
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class MyTest3 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(1000); //自动装箱
list.add(2000);
list.add(3000);
list.add(4000);
list.add(4000);
list.add(500);
//遍历方式1
//list.iterator()
//遍历方式2：List 有一个自己的迭代器
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()){
Object next = listIterator.next();
System.out.println(next);
}
System.out.println("==============================");
//遍历方式3 采用for循环遍历
for (int i = 0; i < list.size(); i++) {
Object o = list.get(i);
System.out.println(o);
}
}
}ListIterator的特有功能
ListIterator 继承自Iterator 可以使用Iterator中的方法
A:ListIterator的特有功能
boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前 要先进行正向遍历 这样指针才能移到最后
如果直接反向遍历是没有效果的 因为指针默认位置就在最前面 他前面没有元素
并发修改异常产生的原因及解决方案
ConcurrentModificationException出现
我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合 会出现并发修改异常
原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器 那么迭代器已经知道了集合的元素个数
这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法） 那迭代器不同意 就报错了
解决方案1 我们用ListIterator迭代器遍历 用迭代器自带的add方法添加元素 那就不会报错了
a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
b:集合遍历元素，集合修改元素
解决方案2 使用for循环遍历集合 添加元素 不会报错List的三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。用哪个 得看 要安全还是要效率
是查找多还是增删多
数据结构
数据结构概述及常见数据结构
数据结构其实就是存储数据的格式
分类: 栈 , 队列 , 数组 , 链表 , 树 , 哈希表
栈特点: 先进后出
队列: 先进先出数据结构之数组和链表
数组特点: 查询快 , 增删慢
链表特点: 查询慢 , 增删快
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
