JAVA基础学习day14--集合一
一、集合的出现
1.1、集合简述
面向对象语言对事物的体现都是以对象形式,为了方便对多个对象的操作,就对象对象进行存储,集合就是存仪储对象最常用的一种试
1.2、数组和集合都是容器
数组也存对象,存储同一种类型,但数组是固定长度的,集合长度是可变。
数组中可以存储基本数据类型,集合只能存储对象
1.3、集合特点
集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。
1.4、结构
二、集合共性方法
2.1、Collection接口*
Collection 层次结构 中的根接口。Collection 表示一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素,而另一些则不允许。一些 collection 是有序的,而另一些则是无序的。JDK 不提供此接口的任何直接 实现:它提供更具体的子接口(如 Set 和 List)实现。此接口通常用来传递 collection,并在需要最大普遍性的地方操作这些 collection。
2.2、共性方法
方法摘要 | ||
---|---|---|
boolean |
add(E e) 确保此 collection 包含指定的元素(可选操作)。 |
|
boolean |
addAll(Collection<? extends E> c) 将指定 collection 中的所有元素都添加到此 collection 中(可选操作)。 |
|
void |
clear()
移除此 collection 中的所有元素(可选操作)。 |
|
boolean |
contains(Object o)
如果此 collection 包含指定的元素,则返回 true。 |
|
boolean |
containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素,则返回 true。 |
|
boolean |
equals(Object o)
比较此 collection 与指定对象是否相等。 |
|
int |
hashCode()
返回此 collection 的哈希码值。 |
|
boolean |
isEmpty()
如果此 collection 不包含元素,则返回 true。 |
|
Iterator<E> |
iterator()
返回在此 collection 的元素上进行迭代的迭代器。 |
|
boolean |
remove(Object o)
从此 collection 中移除指定元素的单个实例,如果存在的话(可选操作)。 |
|
boolean |
removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素(可选操作)。 |
|
boolean |
retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素(可选操作)。 |
|
int |
size()
返回此 collection 中的元素数。 |
|
Object[] |
toArray()
返回包含此 collection 中所有元素的数组。 |
|
|
toArray(T[] a)
返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同。 |
2.3、ArrayList示例
import java.util.*; class CollectionDemo { public static void main(String[] args) { // 声明2个集合容器,并添加元素 List<String> ar1 = new ArrayList<String>(); ar1.add("a"); ar1.add("b"); ar1.add("c"); ar1.add("d"); ar1.add("e"); // 遍历 sop("ar1遍历:"); getIterator(ar1); List<String> ar2 = new ArrayList<String>(); ar2.add("a"); ar2.add("b"); ar2.add("f"); ar2.add("q"); ar2.add("w"); // 增强for循环遍历 sop("ar2遍历:"); getFor(ar2); // 求集合的长度 sop("ar1的长度:" + ar1.size()); sop("ar2的长度:" + ar2.size()); // 比较判断 sop("ar1中有字符a吗 : " + ar1.contains("a")); // 整个集合比较 sop("ar1中有字符ar2吗 : " + ar1.containsAll(ar2)); // 求交集 ar1.retainAll(ar2); sop("求交集"); getFor(ar1); // addALL ar1.addAll(ar2); // 增强for循环遍历 sop("添加ar2后的ar1:"); getFor(ar1); // 删除 ar1.remove("c"); sop("ar1删除指定c后"); getFor(ar1); sop("ar1删除指定集合"); ar1.removeAll(ar2); getFor(ar1); sop("ar1是空吗?" + ar1.isEmpty()); // 清空 ar1.clear(); sop(ar1.size()); } // iterator遍历集合 public static void getIterator(List<String> list) { Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String str = iterator.next(); sop(str); } } // forEach遍历 public static void getFor(List<String> list) { for (String str : list) { sop(str); } } // 打印 public static void sop(Object obj) { System.out.println(obj); } }
结果:
ar1遍历: a b c d e ar2遍历: a b f q w ar1的长度:5 ar2的长度:5 ar1中有字符a吗 : true ar1中有字符ar2吗 : false 求交集 a b 添加ar2后的ar1: a b a b f q w ar1删除指定c后 a b a b f q w ar1删除指定集合 ar1是空吗?true 0
2.4、Iterator
方法摘要 | |
---|---|
boolean |
hasNext() 如果仍有元素可以迭代,则返回 true。 |
E |
next()
返回迭代的下一个元素。 |
void |
remove()
从迭代器指向的 collection 中移除迭代器返回的最后一个元素(可选操作)。 |
2.5、ArrayList
import java.util.ArrayList; import java.util.Iterator; import java.util.List; /** * List:元素是有序的,元素可以重复,该集合体系有索引 * Set:元素是无序,元素不可以重复 * List: * 特有方法:可以操作索引的方法都 是特有 * add(index ,element) * addAll(index,Collection); * remove (index) * set(index,element) * get(index); * subList(from,to) * listIterator() * * */ public class ListDemo { public static void main(String[] args) { //add(); //remove(); //set(); //getIndex(); indexSub(); } //indexOf和subList public static void indexSub(){ List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); list.add("java04"); list.set(2,"hello"); sop(list.indexOf("java04"));//3 sop(list.indexOf("java09"));//-1 sop(list.lastIndexOf("hello"));//2 List<String> subList=list.subList(1, 3); sop(subList);//hello,java03 } //遍历 public static void getIndex(){ List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); list.add("java04"); list.set(2,"hello"); //循环遍历,通过索引的方式遍历和数组一样 for(int x=0;x<list.size();x++){ sop("list["+x+"]="+list.get(x)); } } //修改 public static void set(){ List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); list.add("java04"); list.set(2,"hello"); //遍历 get(list); } //删除元素 public static void remove(){ List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); list.add("java04"); list.remove(2); //遍历 get(list); } //添加元素 public static void add(){ List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); //遍历 get(list); //在指定位置添加 list.add(1,"java09"); //遍历 System.out.println("========在指定位置添加后=========="); get(list); } //遍历 public static void get(List<String> list){ for(Iterator<String> it=list.iterator();it.hasNext();){ sop(it.next()); } } public static void sop(Object obj){ System.out.println(obj); } }
2.6、列表迭代器 listIterator
iterator,只能做判断、删除、取出,不能做其它操作
listIterator
public ListIterator<E> listIterator(int index)
-
返回列表中元素的列表迭代器(按适当顺序),从列表的指定位置开始。指定的索引表示
next
的初始调用所返回的第一个元素。previous
方法的初始调用将返回索引比指定索引少 1 的元素。此实现返回
ListIterator
接口的直接实现,扩展了由iterator()
方法返回的Iterator
接口的实现。ListIterator
实现依赖于底层实现列表的get(int)
、set(int, E)
、add(int, E)
和remove(int)
方法。注意,除非重写列表的
remove(int)
、set(int, E)
和add(int, E)
方法,否则此实现返回的列表迭代器将抛出UnsupportedOperationException
来响应其remove
、set
和add
方法。根据 (protected)
modCount
字段规范中的描述,在面临并发修改时,可以使此实现抛出运行时异常。
方法摘要 | |
---|---|
void |
add(E e) 将指定的元素插入列表(可选操作)。 |
boolean |
hasNext()
以正向遍历列表时,如果列表迭代器有多个元素,则返回 true(换句话说,如果 next 返回一个元素而不是抛出异常,则返回 true)。 |
boolean |
hasPrevious()
如果以逆向遍历列表,列表迭代器有多个元素,则返回 true。 |
E |
next()
返回列表中的下一个元素。 |
int |
nextIndex()
返回对 next 的后续调用所返回元素的索引。 |
E |
previous()
返回列表中的前一个元素。 |
int |
previousIndex()
返回对 previous 的后续调用所返回元素的索引。 |
void |
remove()
从列表中移除由 next 或 previous 返回的最后一个元素(可选操作)。 |
void |
set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素(可选操作)。 |
package com.pb.list.demo1; import java.util.ArrayList; import java.util.List; import java.util.*; public class ListIteratorDemo { public static void main(String[] args) { List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); list.add("java04"); list.add("java05"); //获取listIterator迭代器 ListIterator<String> listIterator=list.listIterator(); while(listIterator.hasNext()){ if(listIterator.next().equals("java02")){//判断 //修改 listIterator.set("java007"); //添加 listIterator.add("hello"); } } sop(list); //倒序输出遍历 while(listIterator.hasPrevious()){ sop(listIterator.previous()); } } public static void sop(Object obj){ System.out.println(obj); } }
2.7、Vector
package com.pb.list.demo1; import java.util.ArrayList; import java.util.Enumeration; import java.util.List; import java.util.Vector; public class VectorDemo { public static void main(String[] args) { Vector<String> vector=new Vector<String>(); //添加元素 vector.add("java01"); vector.add("java02"); vector.add("java03"); vector.add("java04"); vector.add("java05"); //获取枚举 Enumeration<String> en=vector.elements(); while(en.hasMoreElements()){ System.out.println(en.nextElement()); } } }
2.8、LinkedList
package com.pb.list.demo1; import java.util.LinkedList; /** * LinkedList特有方法: * 添加元素到第一个索引位置 addFirst(); * 添加元素到最后一个索引位置 addLast(); * 获取索引为0的元素 getFirst(); * 获取索引最后的元素 getLast(); * 删除索引为0的元素 removeFirst(); * 删除索引为size()-1的元素 * removeLast(); */ public class LinkedListDemo { public static void main(String[] args) { // 声明一个链表集合 LinkedList<String> list = new LinkedList<String>(); // 添加到第一个元素 list.addFirst("1"); list.add("2"); list.add("3"); sop(list);// 3,2,1 // 将元素添加到最后 list.addLast("6"); list.addLast("5"); list.addLast("4");// 3,2,1,6,5,4 sop(list);// 获取第一个元素 sop(list.getFirst());//3 // 获取最后一个元素 sop(list.getLast());// 4 // 删除第一个元素 sop(list.removeFirst()); // 删除最后一个 sop(list.removeLast()); sop(list);// 2,1,6,5 /* * 获取集合全部元素,不使用迭代器 */ while (!list.isEmpty()) { list.removeFirst();// list.removeLast(); } } public static void sop(Object obj) { System.out.println(obj); } }
removeFirst或者removeLast
public E removeFirst()
移除并返回此列表的第一个元素。
- 指定者:
- 接口
Deque<E>
中的removeFirst
-
返回:
此列表的第一个元素
抛出:
NoSuchElementException
- 如果此列表为空JDK 1.6之后提供了新的方法
pollFirst或者pollLast
public E pollFirst()
示例
package com.pb.list.demo1; import java.util.LinkedList; /** * JDK 1.6提供了新的方法 * offerFirst(),添加元素到第个 * offerLast(),添加元素到最后一位 * * peekFirst()获取第一个元素 * peekLast()获取最后一个元素 * * pollFirst()删除第一个元素 * pollLast()删除最后一个元素 * */ public class LinkedListDemo1 { public static void main(String[] args) { // 声明一个链表集合 LinkedList<String> list = new LinkedList<String>(); // 添加到第一个元素 list.offerFirst("1"); list.offerFirst("2"); list.offerFirst("3"); sop(list);// 3,21 // 将元素添加到最后 list.offerLast("6"); list.offerLast("5"); list.offerLast("4");// 3,2,1,6,5,4 sop(list); // 获取第一个元素 sop(list.peekFirst());// 3 // 获取最后一个元素 sop(list.peekLast());// 4 // 删除第一个元素 sop(list.pollFirst()); // 删除最后一个 sop(list.pollLast()); sop(list);// 2,1,6,5 /* * 获取集合全部元素,不使用迭代器 */ while (!list.isEmpty()) { list.pollFirst();// list.pollLast() } } public static void sop(Object obj) { System.out.println(obj); } }
示例:
package com.pb.list.demo1; import java.util.LinkedList; /** * 使用LinkedList模拟一个堆栈或者队列数据结构 * 堆栈:先进后出 * 队列:先进先出 * * */ public class LinkedListDemo2 { public static void main(String[] args) { Que q=new Que(); q.myAdd("java01"); q.myAdd("java02"); q.myAdd("java03"); q.myAdd("java04"); q.myAdd("java05"); while(!q.isNUll()){ //输出 System.out.println(q.myGet()); } } } class Que{ private LinkedList list=null; public Que(){ list=new LinkedList(); } //判断是不是NULL public boolean isNUll(){ return list.isEmpty(); } //添加 public void myAdd(Object obj){ list.offerFirst(obj); } //删除 public Object myGet(){ return list.pollLast(); //先出 // return list.pollFirst(); } }
示例,去除list的重复元素
package com.pb.list.demo1; import java.util.ArrayList; import java.util.Iterator; /** * 去除ArrayList中的重复元素 * @author Administrator * */ public class ArrayListDemo1 { public static void main(String[] args) { ArrayList list=new ArrayList(); list.add("java01"); list.add("java01"); list.add("java02"); list.add("java02"); list.add("java03"); list.add("java03"); list.add("java019"); System.out.println(getSingle(list)); } public static ArrayList getSingle(ArrayList list){ ArrayList tempList=new ArrayList(); for(Iterator it=list.iterator();it.hasNext();){ Object obj=it.next(); if(!tempList.contains(obj)){ tempList.add(obj); } } return tempList; } }
示例,去除list的重复对象
package com.pb.list.demo1; public class Person { private String name; private int age; //重写equals @Override public boolean equals(Object obj) { if(!(obj instanceof Person)){ return false; } Person p=(Person)obj; return this.name.equals(p.name)&&this.age==p.age; } public Person() { super(); // TODO Auto-generated constructor stub } public Person(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; } public void show(){ System.out.println(this.name+"........"+this.age); } }
package com.pb.list.demo1; import java.util.ArrayList; import java.util.Iterator; /** * 去除ArrayList中的重复元素 * @author Administrator * */ public class ArrayListDemo1 { public static void main(String[] args) { Person p1=new Person("张三",19); Person p2=new Person("张三",19); Person p3=new Person("李四",23); Person p4=new Person("李四",23); Person p5=new Person("王五",33); Person p6=new Person("王五",23); Person p7=new Person("赵六",18); ArrayList<Person> list=new ArrayList<Person>(); list.add(p1); list.add(p2); list.add(p3); list.add(p4); list.add(p5); list.add(p6); //遍历去掉重复后的 for(Person p:getSingle(list)){ p.show(); } } public static ArrayList<Person> getSingle(ArrayList<Person> list){ ArrayList<Person> tempList=new ArrayList<Person>(); for(Iterator<Person> it=list.iterator();it.hasNext();){ Person p=it.next(); if(!tempList.contains(p)){ //contains也是调用对象equals方法 tempList.add(p); } } return tempList; } }
2.9、三种集合区别
ArrayList:底层的数据结构使用是数组结构,遍历快,增、删、改,慢,线程不同步
LinkedList:底层的数据结构使用链表数据结构,遍历慢,增、删、改,快,
Vector:底层的数据结构使用是数组结构,线程同步的,被ArrayList替代了。
三、Set
3.1、List和Set区别
List:元素是有序的,元素可以重复,该集合体系有索引
Set:元素是无序,元素不可以重复
一个不包含重复元素的 collection。更确切地讲,set 不包含满足 e1.equals(e2)
的元素对 e1
和 e2
,并且最多包含一个 null 元素。
3.2、常见子类
HashSet--哈希表,TreeSet
3.3、功能方法
Set的方法和Collection一样,使用方式也一样
package com.pb.list.demo1; public class Person { private String name; private int age; //重写hashCode @Override public int hashCode() { System.out.println("========hashCode"); return name.hashCode()+age*39; } //重写equals @Override public boolean equals(Object obj) { if(!(obj instanceof Person)){ return false; } Person p=(Person)obj; System.out.println(p.name+"========equals"+p.age); return this.name.equals(p.name)&&this.age==p.age; } public Person() { super(); // TODO Auto-generated constructor stub } public Person(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; } public void show(){ System.out.println(this.name+"........"+this.age); } }
package com.pb.list.demo1; import java.util.HashSet; import java.util.Iterator; public class Demo1 { public static void main(String[] args) { Person p1=new Person("张三",19); Person p2=new Person("李四",20); Person p3=new Person("张三",19); Person p4=new Person("李四",20); Person p5=new Person("五一",19); Person p6=new Person("五一",19); HashSet<Person> set=new HashSet<Person>(); set.add(p6); set.add(p5); set.add(p4); set.add(p3); set.add(p2); set.add(p1); Iterator<Person> iterator=set.iterator(); while(iterator.hasNext()){ Person p=iterator.next(); p.show(); } } }
========hashCode ========hashCode 五一========equals19 ========hashCode ========hashCode ========hashCode 李四========equals20 ========hashCode 张三========equals19 李四........20 张三........19 五一........19
ArrayList:判断元素是否存或者删除依赖的方法equals()方法
Set:判断元素是否存或者删除,依赖的方法hashCode()和equals()方法,先判断hashCode如果有再判断equals