为什么学习集合?
数组,变量
- 之前的数据保存数组(长度是固定不变的,对数组的元素增加和删除操作起来非常麻烦),变量中
- 集合存储任意类型(基本包装类型,引用类型)
- 集合对元素的增删查改操作起来非常方便的,专门提供很多方便操作的方法
- 开发中经常集合来操作数据的,开发地位比较高的
- 考虑对数据的操作效率上的问题
- 概念?
- 把集合看做是一个容器
- 集合不是一个类,是一套集合框架,框架体系包含很多的集合类,java api提供了
- 集合保存各种类型的数据,很方便的操作
- 特点?
1.关心集合是否可以存储null值
2.关心集合是否可以唯一(是否允许重复)
3.关心集合是线程安全的
4.关心集合是否支持排序的
5.关心集合是否有序,无序的
6.关心集合的底层数据结构是什么(效率问题) - 集合框架体系
- 单列集合
-
Collection接口父类
-
常用方法:
-
boolean add(E e) 添加一个元素的方法,添加成功,返回true
-
boolean addAll(Collection<? extends E> c) 添加一个集合
-
void clear() 清除元素
-
boolean contains(Object o) 是否包含指定的某个元素
-
boolean containsAll(Collection<?> c) 是否包含某个集合
-
boolean isEmpty() 是否为空,为空返回true,否则返回false
-
boolean remove(Object o) 删除某个元素
-
boolean removeAll(Collection<?> c) 删除某个集合
-
int size() 获取集合的长度
-
遍历方法:
-
Iterator<E> iterator() 集合提供的一个迭代器
-
Object[] toArray() 转成数组
-
<T> T[] toArray(T[] a) 泛型在后面讲解
-
List子接口类
-
Set子接口类
- 双列集合
-
Map
- 顶层父类
- 常用方法
- 遍历方法
- 工具类
/**
- Collection接口类方法
- List接口
- 添加
-
boolean add(E e) 添加一个元素
-
void add(int index, E element) 添加某个元素到指定位置
-
boolean addAll(Collection<? extends E> c) 添加一个集合
-
boolean addAll(int index, Collection<? extends E> c) 添加一个集合到指定位置
- 删除
-
E remove(int index) 删除指定位置的元素
-
boolean remove(Object o) 删除某个元素
-
boolean removeAll(Collection<?> c) 删除一个集合
- 修改
-
E set(int index, E element)
- 获取
-
E get(int index)
-
int size()
- 其他
-
int indexOf(Object o)
-
int lastIndexOf(Object o)
-
List<E> subList(int fromIndex, int toIndex)
- 遍历
-
E get(int index) + int size()
-
ListIterator<E> listIterator()
-
ListIterator<E> listIterator(int index)
/
/*
- 遍历
-
-
E get(int index) + int size()
-
-
-
ListIterator<E> listIterator()
-
-
-
ListIterator<E> listIterator(int index)
-
-
iterator();
-
toArray();
-
foreach
-
toString
-
for()
-
for()
/
/*
* 去除集合中重复的元素
*/
public class ListDemo03 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Employee(101,"张三",20,2000.0));
list.add(new Employee(102,"李四",30,3000.0));
list.add(new Employee(103,"王五",20,2000.0));
list.add(new Employee(103,"王五",20,2000.0));
//创建一个新的集合
// List newList = new ArrayList();
// for(Object obj : list){
// if (!newList.contains(obj)){
// newList.add(obj);
// }
// }
// list = newList; //把新集合的数据赋值给到老集合
// //遍历老集合
// for(Object obj : list){
// System.out.println(obj);
// }
//第二种去除重复的方式
//冒泡,选择,比较equlas
//根据选择排序的思想,从第一个元素依次和后面的每一个元素
for (int i = 0; i < list.size(); i++) {
for (int j = i+1; j < list.size(); j++) {
//进行比较,如果第一个元素和第二个元素是相等
//把第二个元素删除
if (list.get(i).equals(list.get(j))){
list.remove(j);
j--;
}
}
}
for(Object obj : list){
System.out.println(obj);
}
}
}
/**
- 泛型
- Collection集合都可以存储任意类型,Object,String,Integer,Double
- 1.需要做向下转型
- 2.为了提高安全性(解决风险性,类型没有确定,在做处理不是特别方便,可能会遇到异常,还需要做更多
- 的处理,比如判断之类,所以就会显得比较麻烦)
- 好处?
- 1.简化了代码
- 2.提高了安全性
- 3.规范类型
- 泛型分类
- 泛型类
- 泛型接口
- 泛型方法
- 定义泛型的时候,规范是如下
- 语法格式:,<A,B>
- 类型用大写的字母表示,A-Z
- 定义一个类型可以,定义多个类型也可以,以逗号之间隔开
- 泛型限定符
/
/*
* 泛型接口
*/
public interface GenericeInterface<E,H> {
void test1();
E test2();
H test3(E e);
}
//实现类,在实现泛型接口的时候,需要确定类型
class GenericeInterfaceImpl implements GenericeInterface<Integer,String>{
@Override
public void test1() {
System.out.println("test1.............");
}
@Override
public Integer test2() {
return 100;
}
@Override
public String test3(Integer integer) {
System.out.println(integer);//10
return "你好";
}
}
public class TestGenericeInterface {
public static void main(String[] args) {
GenericeInterface<Integer,String> gif = new GenericeInterfaceImpl();
gif.test1();
Integer i = gif.test2();
System.out.println(i);//100
System.out.println(gif.test3(10));//10
}
}
* 泛型方法
*/
public class GenericeMethod<G,H> {
public void show1(H h){
System.out.println(h);
}
//返回类型的时候,规定一种类型<类型>
public <A> A show2(A h){
return h;
}
public G show3(G g,H h){
System.out.println(h);//java
return g;//300
}
}
public class TestGenericeMethod {
public static void main(String[] args) {
//在创建对象的时候,确定类型
GenericeMethod<Integer,String> gm = new GenericeMethod<>();
gm.show1("hello");
Integer s = gm.show2(100);
System.out.println(s);
Integer i = gm.show3(300, "java");
System.out.println(i);
}
}
* 定义的泛型类
*/
public class GenericeClass<E,T> {
//属性
private E e;
private T t;
public E getE() {
return e;
}
public void setE(E e) {
this.e = e;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
public class TestGenericeClass {
public static void main(String[] args) {
//在使用泛型类的时候,需要确定类型
GenericeClass<String,Integer> gc = new GenericeClass<>();
gc.setE("hello"); //设置字符串类型
System.out.println(gc.getE());//获取赋予字符串类型的值
gc.setT(10); //设置整数类型的值
System.out.println(gc.getT());
}
}