1.对象数组
就是数组中的元素都是一个个的对象，但是并不是指对象本身，而是指的是对象的引用，即指向对象的那个指针，而这个指针是存放在虚拟机内存的栈中。
对象数组的创建需要两个步骤：
1：创建一个数组，存放对象的引用。
2：具体指出每个引用指向那个对象(用new实现)。
例如：需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。
学生：Student
成员变量：name,age
构造方法：无参,带参
成员方法：getXxx() / setXxx()
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}public static void main(String[] args) {
Student student1= new Student("张三",34);
Student student2 = new Student("李四",32);
Student student3 = new Student("王力宏",31);
/* Student[] students=new Student[3];
students[0]=s1;
students[1] = s2;
students[2] = s3;
*/
//对象数组： 数组即可以存储基本数据类型，也可以存储引用数据类型。
Student[] students=new Student[]{student1,student2,student3};
for (int i = 0; i < students.length; i++) {
Student student=students[i];
System.out.println(student.getName() + "---" + student.getAge());
}//张三---34
//李四---32
//王力宏---31
//数组作为容器的不好之处，就是对容器中的元素，进行操作时，不够方便，比如要增删数组中的元素，就不是那么方便了。
//因为数组一旦定义，长度就不能改变了。
Student[] arr2 = new Student[4];
arr2 = Arrays.copyOf(students, 4);
arr2[arr2.length-1]=student3;
System.out.println(Arrays.toString(arr2));
//[Student{name='张三', age=34}, Student{name='李四', age=32}, Student{name='王力宏', age=31}, Student{name='王力宏', age=31}]
}2.集合
2.1集合的由来及集合继承体系图
1.集合的由来：
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。
2.数组和集合的区别：
(1): 长度区别:
数组的长度是固定的而集合的长度是可变的
(2): 存储数据类型的区别:
数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
(3): 内容区别:
数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素
3.集合继承体系图：
2.2Collection(集合)接口
2.21Collection的功能概述(通过API查看即可得到)
1.添加功能
boolean add(Object obj):添加一个元素。
public static void main(String[] args) {
Collection collection= new ArrayList();
//往集合中添加元素,基本类型和引用
boolean b = collection.add("张曼玉");
System.out.println(b); //true表示添加成功
collection.add("钟楚红");
collection.add("张敏");
collection.add("毛舜筠");
System.out.println(collection);//[张曼玉, 钟楚红, 张敏, 毛舜筠]
//因为collection重写了toString
}public static void main(String[] args) {
int num=300;
Collection collection = new ArrayList();
collection.add(Integer.valueOf(100));
collection.add(200);//集合只能存储引用数据类型，但是包装类有自动装箱和拆箱的功能
collection.add(num);
collection.add(Integer.valueOf(400));
System.out.println(collection);
}boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(100);
collection.add(200);
Collection collection2 = new ArrayList();
collection2.add(300);
collection2.add(400);
//把两个集合中的元素，归并到一个集合里面去
// 返回值是有没有添加成功
boolean b = collection.addAll(collection2);
System.out.println(b);//true
System.out.println(collection);//[100, 200, 300, 400]
System.out.println(collection2);//[300, 400]添加过程中collection2没有发生变化
}2.删除功能
void clear():移除所有元素
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(100);
collection.add(200);
collection.clear();
System.out.println(collection); //[]
}boolean remove(Object o):移除一个元素
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(100);
collection.add(200);
//删除集合中的某个元素
collection.remove(100);
System.out.println(collection);//[200]
}boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素 如果没有交集元素 则删除失败 返回false
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(100);
collection.add(200);
collection.add(500);
Collection collection2 = new ArrayList();
collection2.add(100);
collection2.add(200);
collection2.add(300);
collection2.add(400);
boolean b = collection.removeAll(collection2);
System.out.println(b); //true
System.out.println(collection); //[500] collection里面的元素会变化
System.out.println(collection2); //[100, 200, 300, 400]
}3.判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(100);
collection.add(200);
collection.add(500);
//contains(1000) 判断集合中有没有该元素
System.out.println(collection.contains(1000));//false
}boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素**(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)**
比如：1，2，3 containsAll 12=true 1,2,3 containsAll 2,3,4=false
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(100);
collection.add(200);
collection.add(500);
collection.add(300);
collection.add(400);
Collection collection2 = new ArrayList();
collection2.add(100);
collection2.add(200);
collection2.add(300);
collection2.add(400);
boolean b = collection.containsAll(collection2);
System.out.println(b); //true
}boolean isEmpty()：判断集合是否为空
public static void main(String[] args) {
System.out.println("".isEmpty());//true
}4.获取功能Iterator接口 iterator迭代器
Iterator iterator()(重点)
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(100);
collection.add(200);
collection.add(300);
collection.add(400);
collection.add(500);
//size() 获取集合的长度
System.out.println(collection.size());//5
// Iterator 接口 对 collection 进行迭代的迭代器。
Iterator iterator = collection.iterator();
System.out.println(iterator);//java.util.ArrayList$Itr@1540e19d
//内部类 为什么把迭代器 Itr 设计为内部类
//为了降低耦合，Iterator也要作为组件去复用的，而不仅仅是Collection接口中使用了它。
/*方法摘要
boolean hasNext ()
如果仍有元素可以迭代，则返回 true。
E next ()
返回迭代的下一个元素。*/
while (iterator.hasNext()){
Object obj = iterator.next();
System.out.println(obj);//100
//200
//300
//400
//500
}
}5.长度功能
int size():元素的个数。
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(100);
collection.add(200);
collection.add(300);
collection.add(400);
collection.add(500);
//size() 获取集合的长度
System.out.println(collection.size());//5
}6**.交集功能**
boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化 。
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(1000);
collection.add(200);
collection.add(500);
Collection collection2 = new ArrayList();
collection2.add(100);
collection2.add(200);
collection2.add(300);
collection2.add(400);
boolean b = collection.retainAll(collection2);
System.out.println(b); //true
System.out.println(collection); //[200]
System.out.println(collection2);//[100, 200, 300, 400]
}7.把集合转换为数组Object[] toArray()
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(1000);
collection.add(200);
collection.add(300);
collection.add(400);
collection.add(500);
/* //定义数组
Object[] objArr=new Object[collection.size()];
Iterator iterator = collection.iterator();
int index=0;
while (iterator.hasNext()) {
Object obj = iterator.next();
objArr[index]=obj;
index++;
}
System.out.println(Arrays.toString(objArr));*/
//toArray(); 把集合转换为数组
Object[] objects = collection.toArray();
System.out.println(Arrays.toString(objects));//[1000, 200, 300, 400, 500]
}2.3List接口(colle)
2.31List概述及特点
元素有序( 存取顺序一致),并且每一个元素都存在一个索引,索引 从0开始，元素可以重复。
1.List集合的特有功能概述
list.subList(0, 2); 根据起始索引和终止索引，截取集合中的一部分元素，放到一个新集合中。
public static void main(String[] args) {
List list = new ArrayList();
list.add("world");
list.add("aaa");
list.add("bbb");
//list.subList(0, 2); 根据起始索引和终止索引，截取集合中的一部分元素，放到一个新集合中。
List list1 = list.subList(0, 2); //含头不含尾
System.out.println(list1);
} void add(int index,E element): 在指定索引处添加元素
E remove(int index):移除指定索引处的元素 返回的是移除的元素
public static void main(String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
//根据元素来删除
list.remove("aaa");
//根据索引来删除集合中的元素
list.remove(2);
System.out.println(list);//[bbb, ccc]
} E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素
int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(100);
list.add(200);
list.add(300);
//在指定索引出添加元素
list.add(0,500);
System.out.println(list);
}public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(100);
list.add(200);
list.add(300);
//IndexOutOfBoundsException: Index: 100, Size: 4
// list.remove(100);
//如果索引和元素区分不出来，你把元素包装一下。
list.remove(Integer.valueOf(100));
System.out.println(list); //[100, 200, 300]
//替换集合中的元素 返回的是被替换的那个旧元素
Object oldEle = list.set(list.size() - 1, 3000);
System.out.println(list); //[100, 200, 3000]
System.out.println(oldEle); //300
}2.List集合的特有遍历功能( 使用for循环 通过size()和get()方法结合使用遍历。)
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(200);
list.add(300);
list.add(400);
//get()
for (int i = 0; i < list.size(); i++) {
Object o = list.get(i);
System.out.println(o); //100
//200
//300
//400
}
System.out.println("==========================");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println(obj);
}
System.out.println("==========================");
//List 集合 也有自己的一个迭代器
ListIterator listIterator = list.listIterator();
System.out.println(listIterator);//java.util.ArrayList$ListItr@1540e19d
while (listIterator.hasNext()) {
Object next = listIterator.next();
System.out.println(next);
}
}2.32ListIterator的特有功能(List 集合自己的迭代器)
ListIterator 继承自Iterator 可以使用Iterator中的方法
ListIterator的特有功能
boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前 要先进行正向遍历 这样指针才能移到最后
如果直接反向遍历是没有效果的 因为指针默认位置就在最前面 他前面没有元素
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(200);
list.add(300);
list.add(400);
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
Object obj = listIterator.next();
System.out.println(obj); //100
//200
//300
//400
}
System.out.println("==============================");
/* listIterator.next();
System.out.println(listIterator.hasPrevious());
Object o = listIterator.previous();
System.out.println(o);*/ //NoSuchElementException
//进行反向迭代时，先要正向迭代。
// ListIterator listIterator2 = list.listIterator();
while (listIterator.hasPrevious()) {
Object o1 = listIterator.previous();
System.out.println(o1); //400
//300
//200
//100
}
}2.33并发修改异常产生的原因及解决方案
我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合 会出现并发修改异常。原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器 那么迭代器已经知道了集合的元素个数。这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法） 那迭代器不同意 就报错了
解决方式1：使用迭代器自带的添加删除元素的方法： listIterator
解决方式2：用for循环。
需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
public static void main(String[] args) {
/* A:
案例演示
需求：我有一个集合，请问，我想判断里面有没有 "world" 这个元素，
如果有，我就添加一个 "javaee" 元素，请写代码实现。*/
List list = new ArrayList();
list.add("world");
list.add("aaa");
list.add("bbb");
/* if (list.contains("world")) {
list.add("javaee");
}
System.out.println(list);
*/
//ConcurrentModificationException
/* ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
if (listIterator.next().equals("world")) {
// list.add("javaee");
// list.remove(0);
//解决方式1：使用迭代器自带的添加删除元素的方法
listIterator.add("javaee");
//listIterator.remove();
}
}
*/
System.out.println("=======================================");
//用for循环
for (int i = 0; i < list.size(); i++) {
if (list.get(i).equals("world")) {
list.add("javaee");
}
}
System.out.println(list);
}2.34List的三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
**作业:**去除集合中的重复元素，要求，不能创建新的集合。只在原有集合中操作。
public static void main(String[] args) {
ArrayList list =new ArrayList();
list.add(20);
list.add(20);
list.add(120);
list.add(20);
list.add(202);
list.add(20);
list.add(20);
list.add(20);
list.add(30);
list.add(30);
list.add(20);
list.add(20);
list.add(660);
list.add(40);
list.add(20);
list.add(50);
list.add(50);
list.add(660);
for (int i = 0; i < list.size()-1; i++) {
for (int y= i+1; y < list.size(); y++) {
if(list.get(i).equals(list.get(y))){
list.remove(y);
y--;
}
}
}
Iterator it = list.iterator();
while (it.hasNext()){
Object o = it.next();
System.out.println(o); //20
//120
//202
//30
//660
//40
//50
}
System.out.println(list);//[20, 120, 202, 30, 660, 40, 50]
}3.数据结构
3.1数据结构之栈和队列
数据结构其实就是存储数据的格式。
分类: 栈 , 队列 , 数组 , 链表 , 树 , 哈希表
栈特点: 先进后出
队列: 先进先出
3.2数据结构之数组和链表
数组特点: 查询快 , 增删慢
链表特点: 查询慢 , 增删快
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
