Collection:集合 Array：数组
集合和数组非常类似，都是存储数据的一个容器。
区别：
数组是定长，且只能存储相同类型的数据。
集合是变长，不仅可以存储相同数据而且可以存储不同类型的数据的容器。
Java中的集合可以看成JavaScript的数组。仅仅是概念一样，代码完全不一样。
注：和集合相关的类都需要导包。注意都是java.util下。
Java中的集合分为两大类：
A.单列集合（类似数组，只需要存值，通过下标访问值）
B.双列集合（类似对象，不仅需要存值，还要存与之对应的属性名，通过属性名访问属性值）
Collection就是所有单列集合的父接口
所有单列集合都实现了该接口，所以：所有单列集合都拥有共同的方法。
所以学会了一种单列集合，剩下的单列集合都能依葫芦画瓢。
Collection又分为：
List子接口（内部元素：有序且可以重复）
Set子接口（内部元素：无序且无法重复）
List接口下主要分为以下两个实现类：
ArrayList 集合：采用数组结构，元素增删慢,查找快,由于日常开发中使用最多的功能就是查询,所以 ArrayList 是最常用的集合之一。没有保证线程安全，但是效率高。
Vector集合： 保证了线程安全，但是效率较低。除此和ArrayList都一样
LinkedList 集合：采用链表结构。元素增删快,但是查找慢。
线程安全：保证多个用户共同使用它也不会出错
数组结构：元素增删慢,查找快
链表结构：元素增删快,查找慢
原因：
数组结构是有序的，每个元素都有一个下标，查找的时候只需要根据下标查找即可，所以元素的查找快，但是一旦发生了元素的增加或减少，会引发每个元素的下标发生变化，导致增删慢。
链表结构是无序的，每个元素仅仅存储了本身的值，和引入下一个元素的地址。
所以查询都是一个一个轮流查询，而不是像数组结构，直接根据下标查询。
但是增删快，因为只需要对增删位置的元素进行修改即可，不会影响别的元素。
集合
单列集合(Collection) 双列集合(Map)
List(接口) Set(接口) HashMap(实现类)
ArrayList LinkedList Vector HashSet
import java.util.ArrayList;
import java.util.List;
public class Test2 {
public static void main(String[] args) {
//常见的集合1: ArrayList:
//复习： 特点1：采用了数组结构：查询快。增删慢 特点2：线程非安全所以效率快
//特点3：有序且可以重复 特点4：父类是List 祖父类:Collection
//如何创建一个ArrayList ：类似于多态： 左边放父类 右边放自类
List list = new ArrayList();
// boolean add(Object o); //往集合尾部添加元素，一般不需要返回值
System.out.println(list.add("张三"));
System.out.println(list.add("李四"));
System.out.println(list.add("wangw"));
System.out.println(list.add("jakc"));
// void add(int index, Object o );//往集合指定位置添加元素
list.add(2,"王五");
System.out.println(list);
//常见的方法：
// int size(); //返回集合的长度
System.out.println(list.size());
// boolean isEmpty(); //判断集合的内部是否为null 注意：并不是判断集合为空
System.out.println(list.isEmpty());
// boolean contains(Object o); //判断集合内部是否存在该值
System.out.println(list.contains("张三1"));
// boolean remove(Object o);//删除集合指定的元素值
System.out.println(list.remove(0));//根据下标删除
System.out.println(list.remove("jakc"));
System.out.println(list);
// int indexOf(Object o);//返回指定元素首次出现的位置。-1表示不存在
System.out.println(list.indexOf("王五123"));
// boolean equals(Object o);//判断两个集合是否 值和顺序都相等
// 也重写了Object的equals方法
//Object get(index) 获取指定位置的元素
System.out.println(list.get(2) + "~~");
List l1 = new ArrayList();
List l2 = new ArrayList();
l1.add(123);
l2.add(123);
System.out.println(l1==l2);
System.out.println(l1.equals(l2));
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
public class Test3 {
public static void main(String[] args) {
//复习： 特点1：单列集合 父类是List 祖父类Collction
//特点2：数组结构 特点：有序可重复 线程安全效率低
List list = new Vector();
list.add(true);
list.add("nihao");
System.out.println(list);
//案例：测试ArrayList和Vector 同时增加100000个元素的效率差
long l1 = System.currentTimeMillis();
List list = new ArrayList();
for(int i = 1; i<=1000000;i++) {
list.add(i);
}
System.out.println(list.size());
long l2 = System.currentTimeMillis();//16毫秒
System.out.println(l2-l1);
long l1 = System.currentTimeMillis();
List list = new Vector();
for(int i = 1; i<=1000000;i++) {
list.add(i);
}
System.out.println(list.size());
long l2 = System.currentTimeMillis();//28毫秒
System.out.println(l2-l1);
}
}
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Test4 {
public static void main(String[] args) {
//LinkList:特点： 父类都是List祖父类都是Coolection 有序 可重复
//链表结构 增删快。查询慢
// List list = new LinkedList();
//常见的方法如上一样。
//案例：测试ArrayList 和 LinkList 的效率
List list1 = new ArrayList();
List list2 = new LinkedList();
for(int i = 1; i<=10000000;i++) {
list1.add(i);
list2.add(i);
}
long l1 = System.currentTimeMillis();
int i = list1.indexOf(9999999);
System.out.println(i);
long l2 = System.currentTimeMillis();
System.out.println(l2-l1);
}
}
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
public class Test5 {
public static void main(String[] args) {
//Set集合接口： 特点：单列集合 父类依然是Collection
//特点：无序无法重复。 该接口下有一个常见类：HashSet
Set<Object> set = new HashSet<Object>();
set.add(true);
set.add(123);
set.add("你好");
set.add(123);
System.out.println(set);
//如何遍历集合
//如果List集合 普通for循环即可完成遍历
//但是set集合 没有下标 增强for循环
// for(Object o :set ) {
// System.out.println(o);
// }
//
Iterator<Object> it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
//泛型的概念 ：就是每个集合后面跟着的 <E> E表示这个集合应该存储什么类型的数据
//集合：可以存放不同类型的。但是即使这样，你也要声明
}
}
import java.util.HashSet;
import java.util.Set;
import com.yyzy.entity.Student;
public class Test6 {
public static void main(String[] args) {
Set<Student> set = new HashSet<Student>();
Student s1 = new Student(1, "jack1", 12);
Student s2 = new Student(2, "jack2", 13);
Student s3 = new Student(3, "jack3", 14);
Student s4 = new Student(1, "jack1", 12);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
System.out.println(set);
//无序：如果存放的实体类，会出现一个BUG 当某个实体类的属性完全一致，按理来说应该视为相同的值。但是set不会这么做。
//解决办法：重写hashCode方法即可
//hash：哈希 一种编码 每个对象都有一个独一无二的hash值 你就理解为键盘上的26个字母
Integer a = 123;
String b = "Nihao";
System.out.println(a.hashCode());
System.out.println(b.hashCode());
//存在的意义： 判断对象是否相等
//一般来说判断对象是否相等都是通过== 但是==获取的内存地址 效率较低
//所以hashCode效率较高、 hashCode相等，则进一步判断内存地址 如果hashCode都不能则内存地址肯定不等。
String a1 = new String("111");
String a2 = new String("111");
System.out.println(a1.hashCode());
System.out.println(a2.hashCode());
Student s1 = new Student(1, "jack1", 12);
Student s2 = new Student(1, "jack1", 12);
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
}
}
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test7 {
public static void main(String[] args) {
//Map集合双列集合： 分别存储 键 和 值 键理解为属性名 value属性值
//键绝对是独一无二的 一般来说键：String 值：Object
Map<String,Object> map = new HashMap<String,Object>();
map.put("1001", "张三1");//添加元素
map.put("1002", "张三2");
map.put("1003", "张三3");
System.out.println(map);
System.out.println(map.get("1002"));//获取指定键 对应的值
System.out.println(map.size());
//如何遍历一个map集合
//1.将其转成Set集合
Set<String> set = map.keySet();//将map集合中的键 全部转成set集合
System.out.println(set);
for(String s :set) {
System.out.println(map.get(s));
}
}
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class Test8 {
public static void main(String[] args) {
//使用3种方式 遍历集合的效率
List<Integer> list = new ArrayList<Integer>();
for(int i = 1; i<=10000000;i++) {
list.add(i);
}
System.out.println("准备完毕！！！！！！！！！！");
// 遍历集合的效率
long l1 = System.currentTimeMillis();
for(int i = 0 ;i<list.size();i++) {
if(i==9999999) {
System.out.println("111222");
}
}
long l2 = System.currentTimeMillis();
System.out.println("普通for循环的遍历效率为" + (l2-l1) );//7
long l3 = System.currentTimeMillis();
for(Integer i : list) {
if(i==9999999) {
System.out.println("111222");
}
}
long l4 = System.currentTimeMillis();
System.out.println("增强for循环的遍历效率为" + (l4-l3) );//35
long l5 = System.currentTimeMillis();
//任何集合都可以通过额外一个知识点： Iterator(迭代器)
Iterator<Integer> it = list.iterator();
while(it.hasNext()) {//是否还有下一个元素
if(it.next()==99999999) {
}
}
long l6 = System.currentTimeMillis();
System.out.println("迭代器循环的遍历效率为" + (l6-l5) );//23
}
扫一扫
1111
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
