目录
集合
Java的集合像是一个容器，专门用于存放对象的引用，这些对象可以是任意的数据类型，并且长度可变，其中这些集合都处于java.util的包中
集合按照其存储结构可以分为两大类：单列集合Collection和双列集合Map
单列集合Collection
单列集合的根接口，用来存储一系列符合某一种规则的元素。collection集合有两个重要的子接口List和Set
List集合的特点是元素有序可重复
Set集合的特点是元素无序不重复
双列集合Map
Map集合中每一个元素都包含一对键值，并且key是唯一的，可以通过key找到对应的value
Collection接口
boolean add(Object o)---向集合添加元素
public static void main(String[] args) {
Collection collection=new ArrayList();
// Collection是接口，ArrayList()是这个接口的实现类，类重写了Collection的抽象方法
//通过向上转型，collection可以调用Collection的内部方法，但是抽象方法被重写了，构成了多态
collection.add("ui");
collection.add(1);
collection.add("67");
System.out.println(collection);
}
e的类型是object类型，可以增加任意类型的元素
boolean addAll（Collection c)---将集合c的所有元素增加到该集合
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add("ui");
collection.add(1);
collection.add("67");
System.out.println(collection);
collection.addAll(collection);
System.out.println(collection);
}
void clear（）---删除该集合的所有元素
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add("ui");
collection.add(1);
collection.add("67");
System.out.println(collection);
collection.clear();
System.out.println(collection);
}
boolean remove（Object o）--- 删除该集合中指定的元素（只删除一次）
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add("ui");
collection.add(1);
collection.add(1);
collection.add("67");
System.out.println(collection);
collection.remove(1);
System.out.println(collection);
}
boolean removeAll（Collection c）---删除此集合中所有集合c的元素（重复元素全部删除）
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add("ui");
collection.add(1);
collection.add(1);
collection.add("67");
System.out.println(collection);
Collection collection1=new LinkedList();
collection1.add(1);
collection.removeAll(collection1);
System.out.println(collection);
}
boolean isEmpty（）---判断集合是否为空
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add("ui");
collection.add(1);
collection.add(1);
System.out.println(collection);
System.out.println(collection.isEmpty());
}
boolean contains（Object o）---判断是否含有某一个元素
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add("ui");
collection.add(1);
collection.add(1);
System.out.println(collection);
System.out.println(collection.isEmpty());
System.out.println(collection.contains(1));
}
boolean containsAll（Collectio o）---判断这个集合是否包含集合o的所有元素
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add("ui");
collection.add(1);
collection.add(1);
System.out.println(collection);
Collection collection1=new LinkedList();
collection1.add(1);
collection1.add(3);
System.out.println(collection1);
System.out.println(collection.containsAll(collection1));
}
int size（）---获取该集合的元素个数
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add("ui");
collection.add(1);
collection.add(1);
System.out.println(collection);
System.out.println(collection.size());
}
object【】 toArray（）---返回装有集合中所有元素的数组
public static void main(String[] args) {
Collection collection=new ArrayList();
collection.add("ui");
collection.add(1);
collection.add(1);
Object[] s=collection.toArray();
for (Object o:s) {
System.out.print(o+" ");
}
}
泛型
传入元素类型是Object时，因为Object类是所有类的父类，所以什么元素类型都可以存放
class MyarrayList {
Object[] objects = new Object[10];
int usedsize = 0;
public void add(Object e) {
objects[usedsize++] = e;
}
public Object getObjects(int pos) {
return objects[pos];
}
public void print() {
for (int i = 0; i < usedsize; i++) {
System.out.print(objects[i] + " ");
}
System.out.println();
}
}
public class text {
public static void main(String[] args) {
MyarrayList myarrayList=new MyarrayList();
myarrayList.add("1");
myarrayList.add(1);
myarrayList.add('o');
myarrayList.print();
System.out.println(myarrayList.getObjects(0));
}
}但是如果我们进行了强制类型转化，常常会出现问题
String str=(String) myarrayList.getObjects(1);//返回Object类型，需要强制类型转化
System.out.println(str);
泛型可以解决这个问题---限定操作的数据类型
在实例化类时传入参数：这个实例化对象只能存放String的数据
public static void main(String[] args) {
MyarrayList<String> myarrayList=new MyarrayList<String>();
//传入String类型的数据
myarrayList.add("hello");
//传入int类型的数据
MyarrayList<Integer> myarrayList1=new MyarrayList<>();
myarrayList1.add(1);
//传入char类型的数据
MyarrayList<Character> myarrayList2=new MyarrayList<>();
myarrayList2.add('1');
}使用泛型的意义：自动进行类型检查、自动进行类型转化
泛型的擦除机制
泛型在编译期间已经被擦除为了Object类型
使用泛型数组的注意问题
数组在运行期间存储和检查类型信息，但是泛型在编译期间检查错误，并且运行期间已经被擦除为Object类型
不能使用泛型来定义数组
E[]objects=new E[10];---这行代码错误
错误的原因：
编译期间E类型被擦除为Object类型 ，如果上述代码成功，那么编译期间擦除为
Object[]objects=new Object[10];
但是如果我们将这个数组强制转化为String类型的数组，就会产生错误，为了避免这样的错误，JVM底层不允许这样定义数组
正确的泛型数组定义方式：使用映射
object数组的强制转化
java中，其余数组可以整体向上转型转化为Object数组，但是Object数组向下转型时不能整体转型，要将每个元素单独强转
object类不能引用8个普通类型，要引用普通类型的包装类
public static void main(String[] args) {
String []str=new String[10];
System.out.println(str);
Object[] s=new String[10];//String数组可以向上提升为Object数组
System.out.println(s);
// String [] ret= (String[]) new Object[10];//编译通过
// System.out.println(ret);//运行时抛出异常---Object数组不可以整体强制转化为String数组
// Integer []dest= (Integer []) new Object[10];//编译通过
// System.out.println(dest);//运行抛出异常
Object []dest=new Integer[10];
System.out.println(dest);
Object a=new String[]{"hello","world"};//Object类是所有类的超类
System.out.println(a);
} public static void main(String[] args) {
Object[] s = new String[]{"hello", "world"};
System.out.println(Arrays.toString(s));
Object[]objects=new Object[]{"hello", "world"};
String []str=new String[objects.length];
for (int i = 0; i < objects.length; i++) {
str [i]=(String) objects[i];
}
System.out.println(Arrays.toString(str));
}
1831
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
