集合的概念（什么是集合？）
集合就是对象的容器，它实现了对对象常用的操作，类似数组功能。
集合与数组的区别
- 数组长度固定，而集合长度不固定。
- 数组可以存储基本类型和引用类型，而集合只能存储引用类型
Collection体系集合
Collection是体系的根接口，代表一组对象，称为“集合”。
Collection它所存放的是单一值
- Collection父接口的特点：代表一组任意类型的对象，无序、无下标、不能重复。
- List接口的特点：有序、有下标、元素可重复。
- Set接口的特点：无序、无下标、元素不能重复。
同时它有以下几个特点：
当使用Arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容操作。它可以存放不同类型的数据，而数组只能存放固定类型的数据。
api方法：
增加数据的方法：
- add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程。
- addAll:添加另一个集合的元素到此集合中。
删除数据的方法：
- clear:只是清空集合中的元素，但是此集合对象并没有被回收
- remove:删除指定元素
- removeAll：删除集合元素
查询数据的方法：
- contains:判断集合中是否包含指定的元素值
- containsAll:判断此集合中是否包含另一个集合
- isEmpty:判断集合是否等于空
- retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
- size:返回当前集合的大小
package collection.class4;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(1); //new Integer(1)
collection.add("123"); // new String("123")
collection.add(true); //new Boolean(true)
System.out.println(collection);
Collection collection1 = new ArrayList();
collection1.add("abc");
collection1.add(666);
collection1.add(false);
collection.addAll(collection1);
System.out.println(collection);
System.out.println(collection.contains("abc"));
System.out.println(collection.isEmpty());
System.out.println(collection.size());
Object[] objects = collection.toArray();
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
}
}
Arraylist的使用：
- 存储结构：数组、查找遍历速度快，增删数据慢(特点)
- JDK1.2版本，运行效率快、线程不安全
ArrayList源码分析
- 默认容量大小：private static final int DEFAULT_CAPACITY = 10;
- 存放元素的数组：transient Object[] elementData;
- 实际元素个数：private int size;
- 创建对象时调用的无参构造函数：
public class Demo5 {
public static void main(String[] args) {
ArrayList arrayList=new ArrayList<>();
//1.添加元素
Student s1=new Student("程", 21);
Student s2=new Student("大", 22);
Student s3=new Student("虎", 21);
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
System.out.println("元素个数："+arrayList.size());
System.out.println(arrayList.toString());
//2.删除元素
arrayList.remove(s1);
//arrayList.remove(new Student("程", 21));
//注：这样可以删除吗（不可以）？显然这是两个不同的对象。
//假如两个对象属性相同便认为其是同一对象，那么如何修改代码？
//3.遍历元素
//3.1使用迭代器
Iterator iterator=arrayList.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
//3.2使用列表迭代器
ListIterator listIterator=arrayList.listIterator();
//从前往后遍历
while(listIterator.hasNext()) {
System.out.println(listIterator.next());
}
//从后往前遍历
while(listIterator.hasPrevious()) {
System.out.println(listIterator.previous());
}
//4.判断
System.out.println(arrayList.isEmpty());
//System.out.println(arrayList.contains(new Student("虎", 22)));
//5.查找
System.out.println(arrayList.indexOf(s1));
}
}
泛型的使用
泛型概述
- Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
- 常见形式有泛型类、泛型接口、泛型方法。
- 语法：
- <T,…> T称为类型占位符，表示一种引用类型。
- 好处：
- 提高代码的重用性。
- 防止类型转换异常，提高代码的安全性。
package collection.class4;
public class FanXingClass<A> {
private String name;
private A a;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public A getA() {
return a;
}
public void setA(A a) {
this.a = a;
}
public void show(){
System.out.println("name: " + name + " A:" + a);
}
public void set(A a){
System.out.println("这是set方法中的A" + a);
}
public A get(){
return a;
}
}当做一些集合的统一操作的时候，需要保证集合的类型是统一的，此时需要泛型来进行限制
泛型的优点：
- 数据安全性高。
- 获取数据时效率比较高。
使用方法:
在定义对象的时候，通过<>中设置合理的类型来进行实现泛型的高阶应用:
泛型类：
在定义类的时候在类名的后面添加<E,K,V,A,B>,起到占位的作用，类中的方法的返回值类型和属性的类型都可以使用
- 泛型接口：
在定义接口的时候，在接口的名称后添加<E,K,V,A,B>
- 子类在进行实现的时候，可以不填写泛型的类型，此时在创建具体的子类对象的时候才决定使用什么类型
- 子类在实现泛型接口的时候，只在实现父类的接口的时候指定父类的泛型类型即可，此时，测试方法中的泛型类型必须要跟子类保持一致
泛型方法
在定义方法的时候，指定方法的返回值和参数是自定义的占位符，可以是类名中的T,也可以是自定义的Q，只不过在使用Q的时候需要使用<Q>定义在返回值的前面
- 泛型的上限（工作中不用）
如果父类确定了，所有的子类都可以直接使用
- 泛型的下限（工作中不用）
如果子类确定了，子类的所有父类都可以直接传递参数使用
import java.util.ArrayList;
import java.util.List;
public class FanXingDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("1"); //new Integer(1)
list.add("123"); // new String("123")
list.add("true"); //new Boolean(true)
//
// //遍历集合
// for (int i = 0; i < list.size(); i++) {
// System.out.println(list.get(i));
// }
//
// System.out.println("***************************************");
// for(String o : list){
String str = (String)o;
// System.out.println(o);
// }
// FanXingClass<String> fanXingClass = new FanXingClass<String>();
// fanXingClass.setNum(1);
// fanXingClass.setA("123");
// fanXingClass.show();
//
// FanXingClass<Integer> fanXingClass2 = new FanXingClass<Integer>();
// fanXingClass2.setNum(2);
// fanXingClass2.setA(1234);
// fanXingClass2.show();
//
// FanXingClass<Person> fanXingClass3 = new FanXingClass<Person>();
// fanXingClass3.setNum(3);
// fanXingClass3.setA(new Person("小白",18));
// fanXingClass3.show();
//
// FanXingClass<String> fanXingClass4 = new FanXingClass<String>();
// fanXingClass4.setNum(4);
// fanXingClass4.set("666");
// fanXingClass4.setA("8888");
// System.out.println(fanXingClass4.get());
// fanXingClass4.show();
// FanXingInterface fanXingInterface = new FanXingInterfaceImpl();
// fanXingInterface.test2("666");
// System.out.println(fanXingInterface.test());
FanXingMethod<String> fanXingMethod = new FanXingMethod<String>();
fanXingMethod.setT("666");
fanXingMethod.show(123);
fanXingMethod.show(true);
}
}
FanXingInterface
package collection.class4;
public abstract void test(B b);
public abstract B test2();
}FanXingMethod
package collection.class4;
public class FanXingMethod<T> {
private int id;
private T t;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
public <Q> void show(Q q){
System.out.println(t);
System.out.println(q);
}
}一、Iterator的使用
在java代码中包含三种循环的方式
- do...while
- while
- for
还有一种增强for循环的方式，可以简化循环的编写
所有的集合类都默认实现了Iterable的接口，实现此接口意味着具备了增强for循环的能力，也就是for-each
增强for循环本质上使用的也是iterator的功能
方法：
- iterator()
- foreach()
在iterator的方法中，要求返回一个Iterator的接口子类实例对象
此接口中包含了
hasNext()
next()
在使用iterator进行迭代的过程中如果删除其中的某个元素会报错，并发操作异常，因此
如果遍历的同时需要修改元素，建议使用listIterator（），
ListIterator迭代器提供了向前和向后两种遍历的方式
始终是通过cursor和lastRet的指针来获取元素值及向下的遍历索引
当使用向前遍历的时候必须要保证指针在迭代器的结果，否则无法获取结果值
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class IteratorDemo {
public static void main(String[] args) {
List list = new ArrayList();
list.add(1);
list.add("123");
list.add(true);
list.add(100L);
list.add(10.0d);
//遍历集合
// for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("*******************");
//使用迭代器
// Iterator iterator = list.iterator();
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()){
// if(list.contains("123")){ 并发操作异常
// list.remove("123");
// }
// Object o = listIterator.next();
// if("123".equals(o)){
// listIterator.remove();
// }
System.out.println(listIterator.next());
}
// System.out.println(list);
// System.out.println("*******************");
// //增强for循环
// for(Object i :list){
// System.out.println(i);
// }
System.out.println("*********************************");
while(listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}
}
}二、LinkedList的使用
链表结构实现，增删快，查询慢。
LinkedList源码分析
LinkedList首先有三个属性：
- 链表大小：
transient int size = 0; - （指向）第一个结点/头结点：
transient Node<E> first; - （指向）最后一个结点/尾结点：
transient Node<E> last;
LiKedListDeom
package collection.class4;
import java.util.LinkedList;
/*
* linkedList拥有更加丰富的方法实现，需要用的时候查询api即可，不需要记忆
*
* */
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add(1);
list.add("abc");
list.add(true);
list.add("abc");
list.add(100L);
System.out.println(list);
System.out.println(list.getFirst());
System.out.println(list.getLast());
list.addFirst("ok");
System.out.println(list);
// System.out.println(list.peek());
// System.out.println(list);
// System.out.println(list.poll());
// System.out.println(list);
// System.out.println(list.pop());
// System.out.println(list);
list.push("no");
System.out.println(list);
}
}List的使用
java集合框架：
List：存放的是单一值
特点：
- 可以存放不同类型的数据，而数组只能存放固定类型的数据
- 当使用Arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容操作
api方法：
增加数据的方法
add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程
addAll:添加另一个集合的元素到此集合中
删除数据的方法
clear:只是清空集合中的元素，但是此集合对象并没有被回收
remove:删除指定元素
removeAll：删除集合元素
查询数据的方法
contains:判断集合中是否包含指定的元素值
containsAll:判断此集合中是否包含另一个集合
isEmpty:判断集合是否等于空
retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
size:返回当前集合的大小
//集合转数组的操作
toArray:将集合转换成数组
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
List list = new ArrayList();
list.add(123);
list.add("abc");
list.add(18.0);
list.add(true);
list.add(18.0);
System.out.println(list);
list.add(0,"ok");
System.out.println(list);
Object o = list.get(0);
System.out.println(o);
System.out.println(list.indexOf(18.0));
System.out.println(list.lastIndexOf(18.0));
System.out.println(list.size());
// list.remove(1);
// System.out.println(list);
list.set(4,false);
System.out.println(list);
System.out.println(list.subList(1,4));
}
}
3、Vector的使用
- 数组结构实现，查询快、增删慢；
- JDK1.0版本，运行效率慢、线程安全。Vector
- 数组结构实现，查询快、增删慢；
- JDK1.0版本，运行效率慢、线程安全。
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
Vector vector =new Vector();
vector.add(123);
vector.add("123");
vector.add(true);
vector.add(100L);
System.out.println(vector);
System.out.println(vector.firstElement());
}
}
三、Set的使用
-
特点：无序、无下标、元素不可重复。
-
方法：全部继承自Collection中的方法。
- set不可以通过下标获取对应位置的元素的值，因为无序的特点
- 使用Treeset底层的实现是Treemap,利用红黑树来进行实现
- 设置元素的时候，如果是自定义对象，会查找对象中的equals和hashcode的方法，如果没有，比较的是地址
- 树中的元素是要默认进行排序操作的，如果是基本数据类型，自动比较，如果是引用类型的话，需要自定义比较器
比较器分类：
内部比较器:
定义在元素的类中，通过实现Comparable接口来进行实现
外部比较器:
定义在当前类中，通过实现Comparator接口来实现，但是要将该比较器传递到集合中
注意：外部比较器可以定义成一个工具类，此时所有需要比较的规则如果一致的话，可以复用，而 内部比较器只有在存储当前对象的时候才可以使用 如果两者同时存在，使用外部比较器当使用比较器的时候，不会调用equals方法
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class SetDemo implements Comparator {
public static void main(String[] args) {
// Set set = new HashSet();
// set.add(1);
// set.add("abc");
// set.add(true);
// set.add(100L);
// set.add("abc");
// System.out.println(set);
//遍历集合
// for (int i = 0; i < set.size(); i++) {
// System.out.println(set.get);
// }
//迭代器遍历
// Iterator iterator = set.iterator();
// while(iterator.hasNext()){
// Object obj = iterator.next();
// System.out.println(obj);
// }
//增强for循环
// for(Object o : set){
// System.out.println(o);
// }
// System.out.println("*******************************");
// for(Iterator iterator1 = set.iterator();iterator1.hasNext();){
// System.out.println(iterator1.next());
// }
// Set set = new TreeSet();
// set.add(1);
// set.add(123);
// set.add(5);
// set.add(20);
// set.add("abc");
// set.add("casd");
// set.add("dasd");
// set.add("bfh");
// System.out.println(set);
Set set = new TreeSet(new SetDemo());
set.add(new Person("zhangfei",19));
set.add(new Person("guanyu",20));
set.add(new Person("zhaoyun",18));
set.add(new Person("mashaladi",30));
System.out.println(set);
}
@Override
public int compare(Object o1, Object o2) {
Person p1 = (Person)o1;
Person p2 = (Person)o2;
if(p1.getAge() > p2.getAge()){
return -1;
}else if(p1.getAge() < p2.getAge()){
return 1;
}else{
return 0;
}
}
}
928
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
