【我的Java笔记】Collection集合的概述 & List

1.概念：可以储存对象的容器变量

2.容器变量：

数组，StringBuffer和StringBuilder。

对于数组来说,数组的长度是固定的,不符合实际需求(长度不可变)

StringBuffer始终在内存中返回的是字符串类型,也不满足元素类型变化的要求

3.题目：集合和数组的区别

（1）长度的区别:

   数组:长度是固定的;

   集合:长度是可变的

   （2）存储数据类型的区别:

   数组:可以存储引用类型,可以存储基本数据类型

   集合:只能存储引用类型

   （3）存储元素的区别

   数组:在同一个数组中,只能存储同一种数据类型的元素

   集合:可以存储多种数据类型的元素;   

4.集合体系图

collection（接口）

1.概述：表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。

  一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现

2.collection中的成员方法：
（1）添加功能:

   boolean add(Object e)给集合中添加指定的元素

   boolean addAll(Collection c)添加一个集合中的所有元素

  （2） 删除功能:

   void clear()删除一个集合中的所有元素,暴力删除,(会删除所有，不建议使用)

   boolean remove(Object o)删除一个集合中的指定元素

   boolean removeAll(Collection c)删除一个集合中的所有元素?注：删除一个算是删除
   （3）判断功能:

   boolean contains(Object o)判断一个集合中是否包含指定的单个元素

   boolean containsAll(Collection c)判断一个集合中是否另一个集合;注：包含一个集合中的所有元素算是包含.

   boolean isEmpty()判断集合是否为空,如果为空,则返回true

   （4）交集功能:

   boolean retainAll(Collection c)仅保留此 collection 中那些也包含在指定 collection 的元素
注：交集的元素去集合A里了，如果集合A的元素发生了变化则返回true，没有变化则返回false
若两个集合中元素完全相同，则返回false（集合A没有发生改变）
若两个集合中元素完全不同，则返回true（集合A变为空集）
   （5）获取功能;

   int size()
获取集合中的元素数

   Iterator<E> iterator()迭代器

   （6）转换功能:

   Object[] toArray()将集合转换成数组

例：

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
public static void main(String[] args) {
//创建一个Collection集合对象
Collection c = new ArrayList() ;	//子实现类去实现Collection对象

//添加功能:
//boolean add(Object e):给集合中添加指定的元素
//boolean flag = c.add("hello") ;	//若添加元素，则一定返回true
c.add("hello") ;
c.add("world") ;
c.add("123") ;
System.out.println(c);

//boolean remove(Object o):删除一个集合中的指定元素
System.out.println("remove:"+c.remove("hello")) ;
System.out.println("remove:"+c.remove("javaweb")) ;

//boolean contains(Object o):判断一个集合中是否包含指定的单个元素
System.out.println("contains:"+c.contains("world"));

//boolean isEmpty():判断集合是否为空,如果为空,则返回true
System.out.println("isEmpty:"+c.isEmpty());

//int size():获取集合中的元素数
System.out.println("size:"+c.size());

System.out.println("c:"+c);

}
}

例（将集合转为数组）：

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
public static void main(String[] args) {
//创建Collection集合对象
Collection c = new ArrayList() ;

//给集合中添加元素
c.add("伊卡尔迪") ;
c.add("佩里西奇") ;
c.add("坎德雷瓦") ;

//将集合转换数组
Object[] objs = c.toArray() ;

//遍历对象数组
for(int i = 0 ;i  < objs.length ; i ++){
//需求:获取集合中元素的同时,获取集合中每一个元素的字符串长度
//要获取字符串长度:需要使用length(),该方法属于String类的特有功能
String s = (String) objs[i] ;	//向下转型
4000

System.out.println(s+"----"+s.length());
}
}
}

Iterator(迭代器)

1.集合中的专有遍历方式（接口）：
Iterator iterator( ) 迭代器

2.成员方法：
（1）Object next()获取功能（返回迭代的下一个元素）
（2）boolean hasNext()判断功能（判断一个集合中是否有下一个可以迭代的元素）

3.使用迭代器的循环方法：
（1）while循环while(it.hasNext()){
it.next();
}
（2）for 循环
for(Iterator it=c.iterator() ; it.hasNext() ;)

4.迭代器原理图解：



例：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList() ;//ArrayList是List集合的子实现类(存储和取出一致的)
//给集合中添加元素
c.add("hello") ;
c.add("world") ;
c.add("java") ;
c.add("java") ;
c.add("java") ;
c.add("java") ;

//获取迭代器对象
Iterator it = c.iterator() ;

while(it.hasNext()){
//需求：获取字符串的同时,还要获取字符串长度
//获取元素Object obj = it.next() ;
//向下转型
String s = (String)it.next() ;
System.out.println(s+"----"+s.length());
}
}
}

List (接口)

1.概述：List集合是一个有序的集合（下标和元素是一一对应的）

注：该集合中元素是可以重复的

2.List集合中的特有方法：

（1）添加功能:

   void add(int index, Object element)在列表的指定位置插入指定元素

   （2）删除功能:

   Object remove(int index)移除列表中指定位置的元素（返回被删除的元素）

  
（3）获取功能:

   ListIterator listIterator()列表迭代器:List集合的专有遍历方式

   Object get(int index)返回列表中指定位置的元素

   （4）替换

   set(int index,Object element)用指定元素替换列表中指定位置的元素（返回被替代的元素）

3.List集合中的遍历方式：

（1）toArray ( )

（2）Collection集合中的Iterator iterator ( )

（3）遍历注意事项：

使用迭代器去遍历集合时，不能直接给集合添加元素！

解决方法：①使用迭代器遍历集合，使用迭代器添加元素

     ②使用集合遍历，使用集合添加元素

4.List集合的列表迭代器 ListIterator listIterator()：

（1）正向遍历：①boolean hasNext():判断是否有下一个可以迭代的元素

 ②Object next():如果有可以遍历的元素,就获取这个元素

  

  （2）逆向遍历：
①boolean hasPrevious():判断是否有上一个可以迭代的元素
②  Object  previous():如果有上一个可以迭代的元素,就获取上一个元素

注：要使用逆向遍历则必须现有正向遍历存在，否则直接使用逆向遍历无意义！

例（逆向遍历）：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;

//给集合中添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;

//获取列表迭代器
ListIterator it = list.listIterator() ;
while(it.hasNext()){
String s = (String)it.next();
System.out.println(s);
}

System.out.println("-----------------------");

//boolean hasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)
//Object  previous():如果有上一个可以迭代的元素,就获取上一个元素
while(it.hasPrevious()){
String s = (String)it.previous() ;
System.out.println(s);
}
}
}

练习

/*
* 需求：有一个集合，判断此集合里是否存在“world”这个元素，若存在，则在其后添加一个“javaee”元素
*
* 注：1.当使用迭代器遍历集合时，不能直接给集合去添加元素。否则会抛出异常：
* 		java.util.ConcurrentModificationException:并发修改异常:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常
* 	  2.解决方法：
* 		    使用迭代器遍历集合,使用迭代器添加元素
* 		    使用集合遍历,使用集合添加元素
* */

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListDemo {
public static void main(String[] args) {
//创建List集合对象
List list = new ArrayList() ;

//给集合中添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;

/*
错误方法：
Iterator it = list.iterator() ;
//遍历
while(it.hasNext()){
String s = (String)it.next() ;
//判断
if("world".equals(s)){
//添加元素
list.add("javaee") ;
}
}

注：此种方法错误！使用迭代器遍历集合，不能直接给集合去添加元素。否则会抛出异常：
java.util.ConcurrentModificationException	并发修改异常:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常
*/

//方法1:使用迭代器遍历集合,使用迭代器添加元素
ListIterator it = list.listIterator() ;		//ListIterator迭代器中含有其特有的添加功能add(); 而Iterator迭代器中不存在
while(it.hasNext()){
String s = (String) it.next() ;

//判断
if("world".equals(s)){
//使用迭代器添加
it.add("javaee") ;
}
}

/*
//方法2:使用集合遍历(普通for循环size()和get()相结合),使用集合添加元素
for(int x = 0 ; x <list.size() ; x ++){
String s = (String) list.get(x) ;
//判断
if("world".equals(s)){
//集合添加
list.add("javaee") ;
}
}
*/

//输出集合
System.out.println("list:"+list);
}
}

6重要.List集合子实现类的特点：

（1）ArrayList：
底层数据结构是数组的形式，满足数组结构的特点：查询快，增删慢
从线程安全问题来看：线程不安全，不同步，执行效率高
（2）Vector：
底层数据结构是数组的形式，特点：查询快，增删慢
从线程角度看：线程安全的类，同步，执行效率低
（3）LinkedList：
底层数据结构是链接列表，特点：查询慢，增删快
从线程角度看：线程不安全的一个类，不同步，执行效率高

注：若实现多线程程序，则要使用安全的类（Vector类）

若在一般需求中没有要求，则采用ArrayList类，安全则需使用Vector类

Vector类（List的子实现类）

1.特点：

底层数据结构是数组的形式，特点：查询快，增删慢

从线程角度看：线程安全的类，同步，执行效率低

2.特有功能：
（1）public void addElement(E obj)——>相当于ArrayList类的：add(Object
e)
（2）public Enumeration<E> elements()枚举——>
相当于：Iterator iterator()
Enumeration<E>接口：向量的组件枚举的两个方法：
boolean hasMoreElements()——> 相当于：hasNext()
Object nextElement()——>相当于：next();

LinkedList类（List的子实现类）

1.特点：
底层数据结构是链接列表，特点：查询慢，增删快
从线程角度看：线程不安全的一个类，不同步，执行效率高

2.特有方法：
特有功能:
（1）添加功能：
public void addFirst(E e)将指定元素插入此列表的开头
public void addLast(E e)将指定元素添加到此列表的结尾
（2）获取功能：
public Object getFirst()返回此列表的第一个元素
public Object getLast()返回此列表的最后一个元素
（3）删除功能：
public Object removeFirst()移除并返回此列表的第一个元素
public Object removeLast()移除并返回此列表的最后一个元素

例1：

import java.util.LinkedList;

public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> link = new LinkedList<>();

//添加元素
link.addFirst("hello");
link.addFirst("world");
link.addLast("Java");
System.out.println(link);

//public Object getFirst()返回此列表的第一个元素
//public Object getLast()返回此列表的最后一个元素
String s1 = link.getFirst();
String s2 = link.getLast();
System.out.println(s1+","+s2);

//public Object removeFirst()移除并返回此列表的第一个元素
//public Object removeLast()移除并返回此列表的最后一个元素
String s3 = link.removeFirst();
String s4 = link.removeLast();
System.out.println(s3+","+s4);
}
}

结果：

[world, hello, Java]

world,Java

world,Java

*练习：去除集合中重复元素

练习一

/**
* 需求:ArrayList去除集合中字符串的重复元素
*
* 分析：
* 		1)首先创建一个集合
* 		2)给集合中添加很多重复元素
* 		3)再次创建一个新集合
* 		4)获取迭代器遍历
* 		5)获取到该集合中的每一个元素
* 				判断新集合中是否包含这些有素
* 				有,不搭理它
* 				没有.说明不重复,添加进来
* 		6)遍历新集合
*/

public class ArrayListDemo {
public static void main(String[] args) {

//1)创建一个集合
ArrayList array = new ArrayList() ;

//2)给集合中添加多个重复元素
array.add("hello") ;
array.add("hello") ;
array.add("hello") ;
array.add("world") ;
array.add("world") ;
array.add("world") ;
array.add("Java") ;
array.add("Java") ;
array.add("hello") ;
array.add("Javaweb") ;
array.add("JavaEE") ;
array.add("JavaEE") ;

//3)创建一个新的集合
ArrayList newArray = new ArrayList() ;

//4)遍历旧集合,获取当前迭代器对象
Iterator it = array.iterator() ;
while(it.hasNext()){
String s = (String) it.next() ;

//拿到了每一个字符串元素
//判断新集合是否包含旧集合中的元素

if(!newArray.contains(s)){
//不包含,就将元素直接添加到新集合中
newArray.add(s) ;
}
}

//遍历新集合
Iterator it2 = newArray.iterator() ;
while(it2.hasNext()){
String s = (String) it2.next() ;
System.out.println(s);
}
}
}

练习二

/**
*  需求:ArrayList去除集合中字符串的重复元素,并且不能使用创建新集合的方式
*/

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo1 {
public static void main(String[] args) {

//创建一个集合,添加重复元素
ArrayList array = new ArrayList() ;

array.add("hello") ;
array.add("hello") ;
array.add("hello") ;
array.add("world") ;
array.add("world") ;
array.add("world") ;
array.add("Java") ;
array.add("Java") ;
array.add("hello") ;
array.add("Javaweb") ;
array.add("JavaEE") ;
array.add("JavaEE") ;

//		System.out.println(array);
/**
* 选择排序逻辑(remove()移除元素方法):
* 拿0索引对应的元素依次和后面索引对应的元素进行比较
* 同理,1索引对应的元素和后面.....
* 前面的索引对应的元素如果和后面索引对应的元素重复了,从集合移出后面索引的对应的元素
*/
for(int x = 0 ;x <array.size() -1 ; x ++){
for(int y= x +1 ; y <array.size() ;y++){
//判断
if(array.get(x).equals(array.get(y))){
array.remove(y) ;
y -- ;
}
}
}

//遍历集合
Iterator it = array.iterator() ;
while(it.hasNext()){
String s = (String) it.next() ;
System.out.println(s);
}
}
}

练习三

/*
* ArrayList去除自定义对象的重复值(成员变量值一样)
* */

import java.util.ArrayList;
import java.util.Iterator;

public class Test {
public static void main(String[] args){
Student s1 = new Student("伊卡尔迪",24);
Student s2 = new Student("伊布拉希莫维奇",36);
Student s3 = new Student("伊卡尔迪",24);
Student s4 = new Student("穆里尼奥",51);
Student s5 = new Student("佩里西奇",27);
Student s6 = new Student("斯帕莱蒂",55);
Student s7 = new Student("伊布拉希莫维奇",36);

ArrayList<Student> list = new ArrayList<>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
list.add(s6);
list.add(s7);

//使用双重for循环和ArrayList类中的remove()删除方法
for(int i=0; i<list.size()-1;i++){
for(int j=i+1; j<list.size();j++){
if(list.get(i).equals(list.get(j))){
list.remove(j);
j--;
}
}
}

Iterator<Student> it = list.iterator();
while(it.hasNext()){
Student s = it.next();
System.out.println(s);
}

}
}

class Student{
String name;
int age;

public Student(){

}

public Student(String name, int age) {
super();
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;
}

//重写toString()方法
public String toString(){
return name+","+age;
}

@Override
//重写equals()方法
public boolean equals(Object obj) {
Student s = (Student)obj;
if(s.name==this.name && s.age==this.age){
return true;
}
else{
return false;
}
}

}

例2：使用LinkedList类模仿“栈”结构的特点（addFirst() 和 removeFirst() 方法）

/*
* 需求：自定义栈的集合类
* */

import java.util.LinkedList;

public class StackTest {
public static void main(String[] args) {
MyStack ms = new MyStack();

//调用添加功能
ms.add("hello");
ms.add("world");
ms.add("java");

//判断当前集合是否为空
while(!ms.isEmpty()){
System.out.println(ms.get());
}
}
}

//模仿“栈”特点的工具类
class MyStack {

//成员变量
private LinkedList link ;

//无参构造
//通过无参进行LinkedList集合对象 的创建
public MyStack(){
link = new LinkedList() ;
}

//添加功能
public void add(Object obj){
link.addFirst(obj) ;//向集合中列表插入到第一个元素
}

//获取功能
public Object get(){
return link.removeFirst() ;//删除集合列表中的第一个元素,返回值是被删除的元素
}

//定义判断集合是否为空
public boolean isEmpty(){
return link.isEmpty() ;
}
}