目录
一:集合的分类
数组能存放基本数据类型和引用数据类型
集合只能够存引用数据类型
二:Collection
是单列集合的顶层接口,jdk提供它的(抽象)实现,也提供了更具体的子接口的实现.
没有索引,创建对象采用多态.
Collection <String>list=new ArrayList<>();
//常用的方法
//1.添加元素
list.add("122");
list.add("123");
list.add("123=4");
//删除元素 删除具体内容或者删除索引
list.remove("123");
//remove if 会遍历集合获取没一个元素,然后元素传递到prdicate中,当做参数传递进去
list.removeIf((String S)->{
//删除元素长度为5
return S.length()==5;
});
System.out.println(list);
//清空
//list.clear();
System.out.println(list);
//判断元素是否在集合中
System.out.println(list.contains("122"));
//判断是否为空
System.out.println(list.isEmpty());
//集合长大衣
System.out.println(list.size());二.1迭代器
terator集合的准用遍历方法
iterator<E>iterator(),返回集合中的迭代器对象,默认指向集合的0索引
常用方法
hasnext();判断元素是否可以被取出
E next()获取当前元素
remove()删除指向元素,没有参数,net已经指向当前对象
list.add("122");
list.add("123");
list.add("123=4");
//创建迭代器 多态
Iterator<String> iterator = list.iterator();
//判断是否含有元素,从0索引开始
while (iterator.hasNext()) {
//输出当前元素 ,next向后移动一位
System.out.println(iterator.next());
}List集合
list有序集合,这里的有序指的是存取顺序(怎么存,怎么取出来)
用户可以精准的控制列表中每一个元素的插入位置,可以通过索引访问元素,并搜索列表中的元素
特点:有序,有索引,可以重复
特有方法
//创建对象
List<String> list=new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
System.out.println(list);
//指定位置添加元素
list.add(0,"aaaaa");
System.out.println(list);
//删除索引元素
list.remove(1);
//删除内容
list.remove("a");
System.out.println(list);
//修改指定索引处元素
list.set(0,"aa");
System.out.println(list);
//返回指定索引元素
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}Arralist
Arralist是泛型类,可以约束类型
底层为数组,查询快增删慢
空参数组长度为0,第一次添加元素的时候默认长度为10,属性值为null,
当再一次添加元素的时候和数组长度比较直到,
当元素大于现有长度扩容长度为原来的1.5倍
Linkedlist
底层是数据链表,查询慢,增删快!
//从开头插入指定元素
list.addFirst("1");
System.out.println(list);
//结尾插入
list.addLast("10");
System.out.println(list);
//获取第一个元素
System.out.println(list.getFirst());
//获取最后
System.out.println(list.getLast());
//删除第一个
list.removeFirst();
System.out.println(list);
//删除最后一个
list.removeLast();
System.out.println(list);vector
Vector 是一个古老的集合，JDK1.0就有了,Vector是线程安全的。jdk7和jdk8中通过Vector()构造器创建对象时底层都创建了长度为10的数组.默认扩容为原来的数组长度的2倍。
set集合
不可重复 Hashset Treeset
特点:
可以去除重复
存取顺序不重复
没有索引
TreeSet
特点:
不包含重复元素的集合,没有索引的方法
可以将元素按照规定顺序排序
底层是红黑树
自然排序
1.使用空参构造创建TreeSet集合
2.在自定义类里面实现Compareble接口
3.重写里面的CompareTo方法
public class Student implements Comparable<Student> {
private int age;
private String name;
public Student() {
}
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
@Override
public int compareTo(Student o) {
//便是按照对年龄排序
int i = this.age - o.age;
//代表当前存入元素 o代表已经存好的元素 第一个元素直接存入
return i;
//当返回值为负数放在左边
//当返回值为0重复
//当返回值为正数放右边
}
}
//便是按照对年龄排序
/*int i = this.age - o.age;
i = i == 0 ? this.name.compareTo(o.getName()) : i;
return i;*/
//按照年龄进行排序,从小到大,如果年龄一样就按照首字母排序.如果年龄和姓名一样就不存入
int result = this.age - o.age;
//
if (result==0){
//按照年龄排序
result = this.name.compareTo(o.getName());
return result;
}else {
return result;
}
import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
TreeSet<Student> list = new TreeSet<>();
Student student1 = new Student(12, "张三");
Student student2 = new Student(17, "小胡");
Student student3 = new Student(6, "小明");
list.add(student1);
list.add(student2);
list.add(student3);
System.out.println(list);
}
}
String a="aaa";
String b="aba";
System.out.println(a.compareTo(b));
//依次往后面比较,然后计算a-b比较器排序
TreeSet的带参构造方法使用的是比较器排序对元素进行排序
让构造方法接收Comparator的实现类对象,重写compare()方法
重写方法时一定要注意排序规则必须按照要求的主要条件和次要条件来写
public static void main(String[] args) {
TreeSet<Student> list = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//01代表现在要存入 o2代表要存入
int result=o1.getAge()-o2.getAge();
if (result==0){
result= o1.getName().compareTo(o2.getName());
return result;
}else {
return result;
}
}
});
Student student4 = new Student(6, "w玩大明");
Student student1 = new Student(12, "z张三");
Student student2 = new Student(17, "x小胡");
Student student3 = new Student(6, "a大明");
list.add(student4);
list.add(student1);
list.add(student2);
list.add(student3);
System.out.println(list);
}
对象2-对象1HashSet
特点:
1.底层数据结构是哈希表
2.不能保证存储和取出顺序完全一致
3.没有带索引的方法,多以不能使用普通for遍历
数据唯一
哈希值(哈希值码):是JDK根据对象的地址值或者属性值,算出来的Int类型的整数
public int hascode():根据对象的地址值计算出来的哈希值
没有重写之前按照地址值计算哈希值(同一个对象多次调用出来的哈希值相同)
重写过后按照对象的属性值计算哈希值,(如果不同对象属性值相同那么他们的哈希值相同)
JDK8之前使用的是数组+链表实现
JDK8之后,底层优化,数组+链表+红黑树实现
数组存满16*0.75的时候就会扩容一半
1.创建一个数组的长度16,默认加载因子为0.75的数组,数组名为tabe
2.根据元素的哈希值跟数组的长度计算出应存入的位置
3.判断当前位置是否为null,如果是bull直接存入
4.如果应该存入的位置不是null,调用equals比较属性值,如果一样不存,如果不同则存入.老元素挂在下面map
Map添加两个元素,
MAP<K,V> K:键的数据类型 V:值的数据类型
键不可以重复,值可以重复
键和值一一对应,每个键只能找自己对应的一个值
(键＋值)这个整体我们称之为键值对,键值对对象,java中叫做entry对象
举例:学号+对象
没有索引不能有索引的遍历
创建map对象
1.多态的方式
2.具体实现类HashMap
//创建对象
Map<String,String> map=new HashMap<>();
//添加对象
map.put("0001","郑");
map.put("0002","涛2");
map.put("0003","郑3");
System.out.println(map);
//添加对象 如果添加的键是存在的就会替换原来的值
map.put("0001","郑涛");
map.put("0002","郑涛2");
map.put("0003","郑涛3");
System.out.println(map);
//移除元素
map.remove("0001");
System.out.println(map);
//移除所有的键值对元素
/*map.clear();
System.out.println(map);*/
//判断是否包含指定的键
System.out.println(map.containsKey("002"));
//判断是否包含指定的值
System.out.println(map.containsValue("郑涛"));
//判断是否为空
System.out.println(map.isEmpty());
//获取长度
System.out.println(map.size());
//获取所有的键 map.keySet();
Set<String> key = map.keySet();
System.out.println(key);
//获取值 map.get(s);
for (String s : key) {
String s1 = map.get(s);
System.out.println(s1);
}
//获取键值对 map.entrySet();
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey() + " " + entry.getValue());
}是Map的实现类
Hashmap和HashSet一样,底层是哈希表结构
HashMap
长度为16,默认的加载因子是0.75(扩容时机)
添加规则
1.把加入的元素键值对看成一个整体Entrye对象,根据哈希code计算出键的哈希值,再计算出在数组中存入的位置
如果存在对象,调用equal方法,比较内容,如果不同就挂在下面.链表.
当长度大于等于8的时候自动转为红黑树
小结
依赖hashcode和equls保证键的唯一性
如果键要存储自定义对象要重写hashcode和equels方法
TrreMap
特点
1.trremap和treeset一样底层都是红黑树结构
2.依赖自然排序,或者比较器排序.只根据键的值排序
3.如果键存储的是自定义对象,需要实现comparebla接口,或者比较器排序规则
Collections工具
-
此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合，以及其他一些可能的和最终的。
//操作connection和map的工具类
List list=new ArrayList();
list.add(123);
list.add(-456);
list.add(789);
list.add(789);
System.out.println(list);
//反转操作
// Collections.reverse(list);
//随机处理
// Collections.shuffle(list);
//排序
// Collections.sort(list);
//i和j元素交换
// Collections.swap(list,0,1);
//最大数
// Collections.max(list);
//最小数
// Collections.min(list);
//指定元素出现的频率
//int a= Collections.frequency(list,789);
//复制copy
// List list1= Arrays.asList(new Object[list.size()]);
// Collections.copy(list1,list);
// System.out.println(list1 );
//解决线程安全
List list1 = Collections.synchronizedList(list);
扫一扫
1001
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
