------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流! ----------
Collection总体概述与常用方法
一、Collection(接口):
1. List(接口):1.有序的;2.可以存储重复值;
ArrayList(类):数组实现;不同步的,效率高;
Vector(类):数组实现;同步的,效率低;
LinkedList(类):链表实现;不同步的,效率高;
2. Set(接口):1.无序的;2.不能存储重复值;(全是不同步的)
HashSet(类):哈希表实现;验证重复:hashCode()和equals()
LinkedHashSet(类):链表,哈希表实现;链表:有序;哈希表:唯一
TreeSet(类):树结构;唯一性验证:比较的方法compareTo()或者compare()方法如果返回0,就不存;
对元素排序的:
1.自然排序:
1).存储的对象必须实现Comparable接口
2).重写compareTo()方法;
2.比较器排序:
1).自定义比较器,实现Comparator接口
2).重写compare()方法;
3).实例化TreeSet对象时,传递自定义比较器的对象;(一般我们使用匿名内部类的式)
二、Collection接口的常用方法:
1.基本方法:
boolean add(Object e):将参数e添加到集合
boolean remove(Object o):将参数o从集合中移除
void clear():清空集合
boolean contains(Object o):基于equals()进行判断;
boolean isEmpty():判断集合是否为空
int size():集合中元素的数量;
2.批量方法:
boolean addAll(Collection c):将参数集合,一次性全部添加到当前集合
boolean removeAll(Collection c):移除此 collection 中那些也包含在指定 collection 中的所有元素(可选操作
boolean containsAll(Collection c):如果此 collection 包含指定 collection 中的所有元素,则返回 true
boolean retainAll(Collection c):移除此 collection 中未包含在指定 collection 中的所有元素。
3.遍历的方式:
A.toArray();
B.Iterator()
三、针对上述的常用方法,给出部分代码演示:
1.基本方法的用法:
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class Demo {
public static void main(String[] args) {
//1.定义集合对象
Collection col = new ArrayList();//多态:可存储重复元素
Collection col2 = new HashSet();//不能存储重复元素;
//2.向仓库中添加元素
System.out.println(col.add("孙悟空"));
System.out.println(col.add("猪八戒"));
System.out.println(col.add("沙师弟"));
System.out.println(col.add("唐僧"));
System.out.println(col.add("唐僧"));
System.out.println("---------------------------");
System.out.println(col2.add("孙悟空"));
System.out.println(col2.add("猪八戒"));
System.out.println(col2.add("孙悟空"));
System.out.println("集合元素:" + col);
//3.移除元素
System.out.println("删除元素:唐僧: " + col.remove("唐僧"));
System.out.println("删除元素:白骨精:" + col.remove("白骨精"));
System.out.println("集合元素:" + col);
//4.void clear()
// col.clear();
// System.out.println("清空集合后:" + col);
//5.boolean contains(Object o)
System.out.println("是否包含:白骨精:" + col.contains("白骨精"));
System.out.println("是否包含:孙悟空:" + col.contains("孙悟空"));
//6.boolean isEmpty()
// col.clear();
System.out.println("集合是否为空:" + col.isEmpty());
//7.int size():
System.out.println("集合中元素的数量:" + col.size());
}
}
2.关于遍历的方式:
package cn.itcast_collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Iterator_迭代器 {
public static void main(String[] args) {
//创建集合对象
Collection<Student> col = new ArrayList<Student>();
//将学生对象添加到集合中
col.add(new Student("北城以北",25,99));
col.add(new Student("帆@彼岸",26,99));
/*//使用迭代器(接口)遍历集合,集合对象调用iterator()方法,返回值类型为Iterator接口类型
Iterator<Student> it = col.iterator();//迭代器的类型随着集合的明确而明确泛型,这样下面Student接收值的时候就不需要强转
//使用hasNext()加while循环判断是否还有下一个元素,如果有点话,使用next()
while(it.hasNext()){
Student stu = it.next();
System.out.println("姓名:"+stu.getName()+", 年龄:"+stu.getAge()+", 战斗力:"+stu.getScore());
}*/
//使用for循环精简代码
for(Iterator<Student> it = col.iterator();it.hasNext();){//代码初始化;判断是否有下一个;(循环操作可以省略)
Student stu = it.next();
System.out.println("姓名:"+stu.getName()+", 年龄:"+stu.getAge()+", 战斗力:"+stu.getScore());
}
}
}
关于ArrarList的应用
集合中,ArrayList是最常用的一种集合,因此这是我们必须要掌握的知识!但是,ArrayList没有特有方法,都是使用的父接口中定义的。即:Collection和List中的方法。
Collection在上面已经讲过,这里讲一下List的特有方法。
List接口的常用方法:
1).新增的方法:
void add(int index,E element)
E remove(int index)
E get(int index)
E set(int index,E element)
ListIterator listIterator()
2).遍历的方式:
A.结合Collection的size()和List的get()方法,使用for()循环;
B.ListIterator:可以向前遍历,也可以向后遍历;
Iterator 和 ListIterator的区别:
1.ListIterator是Iterator的子接口;
2.Iterator只能向下遍历;
3.ListIterator可以双向遍历;
对于这些基本方法,这里就不做演示了,大家可以参考Collection中关于基本方法的演示自己试着做一下。下面给出一个例子。这个例子是关于怎样去除ArrayList中重复的元素:
这里给出了两种方法,大家参考一下:
import java.util.ArrayList;
import java.util.List;
/*
*
* 方式一:定义一个新集合;
* 方式二:遍历当前集合,在当前集合的基础上进行修改;
*/
public class Demo {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Student("李四",22));
list.add(new Student("李四",22));
list.add(new Student("李四",22));
list.add(new Student("张三",20));
list.add(new Student("李四",22));
list.add(new Student("李四",22));
list.add(new Student("王五",24));
list.add(new Student("王五",24));
list.add(new Student("王五",24));
list.add(new Student("王五",24));
list.add(new Student("王五",24));
/*
//方式一:
List newList = new ArrayList();
//遍历
loop:
for(int i = 0;i < list.size() ;i++){
Student stu = (Student)list.get(i);
for(int j = 0;j < newList.size() ; j++){
Student stu2 = (Student)newList.get(j);
if(stu.equals(stu2)){
continue loop;
}
}
//将stu添加到newList中
newList.add(stu);
}
//遍历newList
for(int i = 0 ;i < newList.size() ; i++){
Student stu = (Student)newList.get(i);
System.out.println(stu.name + "," + stu.age);
}*/
//方式二:
for(int i = 0; i < list.size() - 1 ; i++){
Student stu1 = (Student)list.get(i);
for(int j = i + 1 ; j < list.size() ; j++){
Student stu2 = (Student)list.get(j);
if(stu1.equals(stu2)){
list.remove(j);
j--;
}
}
}
//遍历原集合
for(int i = 0; i < list.size() ; i++){
Student stu = (Student)list.get(i);
System.out.println(stu.name + "," + stu.age);
}
}
}
泛型
1.在定义集合时,可以指定这个集合内只能装什么类型元素,这种方式就是“泛型”
ArrayList<String> strList = new ArrayList<String>();
或:
ArrayList<String> strList = new ArrayList<>();
或:
ArrayList<String> strList = new ArrayList();
2.泛型类:class MyArrayList<T>{}
1.T:可以是任何字母;大小写都可以;
2.也可以定义多个泛型,中间用逗号隔开;<T,V>
3.泛型方法:
class MyArrayList{
//接收的是什么类型,返回的就是具有这个类型
public <T> T show(T t){
return t;
}
}
4.泛型接口:
interface IA<T>{
T show(T t);
}
子类实现时:
1.可以继续定义泛型:
class A <T> implements IA<T>{
public T show(T t){
}
}
2.可以固定为某个具体类型
class A implements IA<String>{
public String show(String s){
}
}
3.可以将泛型丢弃
class A implements IA{
public Object show(Object o){
}
}
5.泛型的通配符:
1:<?>:
2:<? extends E>:
3:<? super E>:
这里关于泛型通配符不是很好理解,给出一个Demo帮助大家快速掌握:
package cn.itcast.demo11_泛型通配符;
import java.util.ArrayList;
import java.util.List;
/*
* 泛型通配符:
* 1.<?> :
* 1).变量可以指向什么类型的对象:具有任何泛型的集合对象;
* 2).可以存储什么东西:由于?不确定具体类型,所以不能add()任何类型
* 3).取出时用什么接收:只能用Object接收;
* 作用:不能存入,只能获取,所以一般用作方法的返回值声明;
* 2.<? extends E> :
* 1).变量可以指向什么类型的对象:具有E泛型或者E子类泛型的集合;
* 2).可以存储什么东西:由于不确定是哪个E的子类,所以不能存任何东西;
* 3).取出时用什么接收:只能用E及E的父类类型接收;
* 3.<? super E> :
* 1).变量可以指向什么类型的对象:具有E泛型或者E父类泛型的集合;
* 2).可以存储什么东西:只能存储E或者E的子类对象;
* 3).取出时用什么接收:由于存储的可能是任何的E的子类对象,所以只能用Object接收;
*/
class Animal{}
class Cat extends Animal{};
class Dog extends Animal{};
class JMDog extends Dog{};
public class Demo {
public static void main(String[] args) {
//1.<?>
List<?> list1 = new ArrayList<>();
List<?> list2 = new ArrayList<String>();
List<?> list3 = new ArrayList<Animal>();
//
// list2.add("aa");
// list2.add(10);
// list2.add(new Animal());
Object obj = list2.get(0);
//2.<? extends E>
// List<? extends Dog> list4 = new ArrayList<Animal>();//编译错误
List<? extends Dog> list5 = new ArrayList<Dog>();
List<? extends Dog> list6 = new ArrayList<JMDog>();
/*
list5.add("你好");
list5.add(10);
list5.add(new Animal());
list5.add(new Dog());
list5.add(new JMDog());
*/
Dog d1 = list5.get(0);
Animal a1 = list5.get(0);
//3.<? super E>
List<? super Dog> list7 = new ArrayList<Animal>();
List<? super Dog> list8 = new ArrayList<Dog>();
// List<? super Dog> list9 = new ArrayList<JMDog>();
// list7.add(new Animal());
list7.add(new Dog());
// list7.add(new Cat());
list7.add(new JMDog());
Object d = list7.get(0);
}
}
Set集合
Set集合:这里不是特别好理解,对于初学者,能掌握则好,掌握不了能看懂就可以。
1.Set集合的特点:
1).无序(取出时,跟存入时的顺序不一致)
2).不存储重复元素。
2.子类:
1).HashSet:
A.内部使用"哈希表"结构;
B.使用hashCode()和equals()保证元素的唯一;
2).TreeSet:
A.内部使用"树"结构;
B.比较方式:
1.自然排序:
自定义类实现Comparable接口。重写compareTo()
2.比较器排序:
自定义"比较器"实现Comparator接口,重写compare()方法;
实例化TreeSet时,将"比较器"对象传入;
C.无论哪种比较方式,只要返回0,就认为是相等的对象,不存。
3).LinkedHashSet:有序的;
A.内部使用链表、哈希表实现;
B.由链表保证有序;由哈希表保证唯一
这里给出HashSet存储自定义对象时候需要重写hashCode()和equals()做一个示例:两个类Student类和Demo类
import java.util.HashSet;
import java.util.Set;
/*
* 使用HashSet存储自定义对象
*
* 1.需要判断出两个对象中的属性值是否完全一样,需要重写hashCode()和equals();
* 2.怎么重写?
* 鼠标-->右键-->source-->Generate hashCode() and equals()
*/
public class Demo {
public static void main(String[] args) {
//创建集合对象,并添加元素
Set<Student> stuSet = new HashSet<>();
stuSet.add(new Student("张三",20));
stuSet.add(new Student("李四",22));
stuSet.add(new Student("王五",24));
stuSet.add(new Student("王五",24));
//遍历集合并输出
for(Student stu : stuSet){
System.out.println(stu.name + "---" + stu.age);
}
}
}
这里Student类中重写了equals()和HashCode()方法:
public class Student {
String name;
int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
public class Student {
String name;
int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
public class Student {
String name;
int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
一.Set集合:
1.Set集合的特点:
1).无序(取出时,跟存入时的顺序不一致)
2).不存储重复元素。
2.子类:
1).HashSet:
A.内部使用"哈希表"结构;
B.使用hashCode()和equals()保证元素的唯一;
2).TreeSet:
A.内部使用"树"结构;
B.比较方式:
1.自然排序:
自定义类实现Comparable接口。重写compareTo()
2.比较器排序:
自定义"比较器"实现Comparator接口,重写compare()方法;
实例化TreeSet时,将"比较器"对象传入;
C.无论哪种比较方式,只要返回0,就认为是相等的对象,不存。
3).LinkedHashSet:有序的;
A.内部使用链表、哈希表实现;
B.由链表保证有序;由哈希表保证唯一
二:泛型:
1.在定义集合时,可以指定这个集合内只能装什么类型元素,这种方式就是“泛型”
ArrayList<String> strList = new ArrayList<String>();
或:
ArrayList<String> strList = new ArrayList<>();
或:
ArrayList<String> strList = new ArrayList();
2.泛型类:class MyArrayList<T>{}
1.T:可以是任何字母;大小写都可以;
2.也可以定义多个泛型,中间用逗号隔开;<T,V>
3.泛型方法:
class MyArrayList{
//接收的是什么类型,返回的就是具有这个类型
public <T> T show(T t){
return t;
}
}
4.泛型接口:
interface IA<T>{
T show(T t);
}
子类实现时:
1.可以继续定义泛型:
class A <T> implements IA<T>{
public T show(T t){
}
}
2.可以固定为某个具体类型
class A implements IA<String>{
public String show(String s){
}
}
3.可以将泛型丢弃
class A implements IA{
public Object show(Object o){
}
}
5.泛型的通配符:见Demo
1:<?>:
2:<? extends E>:
3:<? super E>:二:泛型:
1.在定义集合时,可以指定这个集合内只能装什么类型元素,这种方式就是“泛型”
ArrayList<String> strList = new ArrayList<String>();
或:
ArrayList<String> strList = new ArrayList<>();
或:
ArrayList<String> strList = new ArrayList();
2.泛型类:class MyArrayList<T>{}
1.T:可以是任何字母;大小写都可以;
2.也可以定义多个泛型,中间用逗号隔开;<T,V>
3.泛型方法:
class MyArrayList{
//接收的是什么类型,返回的就是具有这个类型
public <T> T show(T t){
return t;
}
}
4.泛型接口:
interface IA<T>{
T show(T t);
}
子类实现时:
1.可以继续定义泛型:
class A <T> implements IA<T>{
public T show(T t){
}
}
2.可以固定为某个具体类型
class A implements IA<String>{
public String show(String s){
}
}
3.可以将泛型丢弃
class A implements IA{
public Object show(Object o){
}
}
5.泛型的通配符:见Demo
1:<?>:
2:<? extends E>:
3:<? super E>:二:泛型:
1.在定义集合时,可以指定这个集合内只能装什么类型元素,这种方式就是“泛型”
ArrayList<String> strList = new ArrayList<String>();
或:
ArrayList<String> strList = new ArrayList<>();
或:
ArrayList<String> strList = new ArrayList();
2.泛型类:class MyArrayList<T>{}
1.T:可以是任何字母;大小写都可以;
2.也可以定义多个泛型,中间用逗号隔开;<T,V>
3.泛型方法:
class MyArrayList{
//接收的是什么类型,返回的就是具有这个类型
public <T> T show(T t){
return t;
}
}
4.泛型接口:
interface IA<T>{
T show(T t);
}
子类实现时:
1.可以继续定义泛型:
class A <T> implements IA<T>{
public T show(T t){
}
}
2.可以固定为某个具体类型
class A implements IA<String>{
public String show(String s){
}
}
3.可以将泛型丢弃
class A implements IA{
public Object show(Object o){
}
}
5.泛型的通配符:见Demo
1:<?>:
2:<? extends E>:
3:<? super E>:
package cn.itcast_collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Iterator_迭代器 {
public static void main(String[] args) {
//创建集合对象
Collection<Student> col = new ArrayList<Student>();
//将学生对象添加到集合中
col.add(new Student("北城以北",25,99));
col.add(new Student("帆@彼岸",26,99));
/*//使用迭代器(接口)遍历集合,集合对象调用iterator()方法,返回值类型为Iterator接口类型
Iterator<Student> it = col.iterator();//迭代器的类型随着集合的明确而明确泛型,这样下面Student接收值的时候就不需要强转
//使用hasNext()加while循环判断是否还有下一个元素,如果有点话,使用next()
while(it.hasNext()){
Student stu = it.next();
System.out.println("姓名:"+stu.getName()+", 年龄:"+stu.getAge()+", 战斗力:"+stu.getScore());
}*/
//使用for循环精简代码
for(Iterator<Student> it = col.iterator();it.hasNext();){//代码初始化;判断是否有下一个;(循环操作可以省略)
Student stu = it.next();
System.out.println("姓名:"+stu.getName()+", 年龄:"+stu.getAge()+", 战斗力:"+stu.getScore());
}
}
}