使用集合的目的：
List集合
集合：
可以理解为容器（它的长度可以变大的,而且它存储的都是对象类型）。
List：
它是一个接口，该集合中的元素可以重复，而且是有序的(有下标)。
ArrayList
ArrayList：它的底层是数组结构，它的查询效率高，但是它的添加和删除效率低--因为它要牵涉到数据的迁移。
常见方法: add();size();indexOf(); contains(); get();remove();isEmpty();
创建集合对象
使用方法：
//创建一个集合对象 如果没有指定集合容器的长度默认为10
List list = new ArrayList();
List list1 = new ArrayList(15); 添加的操作
public static void main(String[] args) {
//创建一个集合对象，如果没有指定集合容器的长度，默认为10
ArrayList list = new ArrayList();
//可以添加任何类型
list.add("java01");
list.add("java02");
list.add(15.5);
list.add(18);
list.add(true);
list.add(new Date());
System.out.println(list);
//在下标为2的位置添加元素，并把后面的元素进行位移
list.add(2,"hello");
//打印一个对象时默认调用的为toString()
System.out.println(list);
ArrayList list2 = new ArrayList();
list2.add("a");
list2.add("b");
//添加多个元素，把list2中的每一个元素一一添加到list中
list.addAll(list2);
System.out.println(list);
代码如下：
public static void main(String[] args) {
//创建一个集合对象，如果没有指定集合容器的长度，默认为10
ArrayList list = new ArrayList();
//可以添加任何类型
list.add("java01");
list.add("java02");
list.add(15.5);
list.add(18);
list.add(true);
list.add(new Date());
System.out.println(list);
//在下标为2的位置添加元素，并把后面的元素进行位移
list.add(2,"hello");
//打印一个对象时默认调用的为toString()
System.out.println(list);
ArrayList list2 = new ArrayList();
list2.add("a");
list2.add("b");
//添加多个元素，把list2中的每一个元素一一添加到list中
list.addAll(list2);
System.out.println(list);删除的操作
代码如下：
//删除操作
//移除下标为2的元素
list.remove(2);
System.out.println(list);
//清空集合中的元素
list.clear();
System.out.println(list);
修改的操作
代码如下：
//修改操作
list.set(1,"梁又年");
System.out.println(list);查询的操作
代码如下：
package practice2;
import java.util.ArrayList;
public class ListTest2 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("java01");
list.add("java02");
list.add("java03");
//查询的方法
//根据下标获取的元素
Object o = list.get(1);
System.out.println(o);
//获取集合中元素的个数
int size = list.size();
System.out.println(size);
//判断元素是否在集合中
boolean f = list.contains("java03");
System.out.println(f);
//查询元素第一次在集合中出现的位置
int index = list.indexOf("java01");
System.out.println(index);
//遍历集合中的元素
for (int i=0;i<list.size();i++){
Object o1 = list.get(i);
System.out.println(o1);
}
System.out.println("======================foreach======================");
for (Object o2 : list){
System.out.println(o2);
}
}
}
ArrayList底层源码
LinkedList：
这是一个链表结构
LinkedList：底层双向链表结构，它增加和删除效率高，但是它的查询效率低（只需要改变链表得指向）。
常见的方法: 它的方法和ArrayList中的方法比较相似，它也有自己特有的方法:
addFirst() ， addLast() ， getFirst() ， getLast()
分析: LinkedList查询效率低。因为它要一个节点一个节点的往后找。
1.添加
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
//追加尾部
linkedList.add("java01");
linkedList.addFirst("java02");
linkedList.addLast("java03");
linkedList.addFirst("java04");
linkedList.addLast("java05");
System.out.println(linkedList);2.删除
//删除操作
//移除头部元素
linkedList.removeFirst();
System.out.println(linkedList);
linkedList.remove(2);
System.out.println(linkedList);3.修改
//修改操作
linkedList.set(1,"java11");
System.out.println(linkedList);4.查询
//查询操作
//求长度
int size = linkedList.size();
//判断是否为空
boolean empty = linkedList.isEmpty();
//判断元素是否在集合中
boolean b = linkedList.contains("java01");
//根据下标位置获取指定位置的元素
Object o = linkedList.get(1);
//获得第一个元素
Object first = linkedList.getFirst();
System.out.println(first);
Object last = linkedList.getLast();
System.out.println(last);Set集合
Set：无序，不可重复
HashSet集合
HashSet：底层依据于HashMap。
1.创建HashSet对象
public class Test3 {
public static void main(String[] args) {
HashSet hashSet= new HashSet();
//初始容器的大小
HashSet hashSet1 = new HashSet(8);
//loadFactor: ——0.7f 表示负载因子 当空间使用70%时 要求扩容
HashSet hashSet2 = new HashSet(8,0.7f);
}
}2.添加元素
//添加操作
hashSet.add("java01");
hashSet.add("java02");
hashSet.add("java04");
hashSet.add("java03");
hashSet.add("java02");
HashSet set2=new HashSet();
set2.add("梁又年");
set2.add("夏淼淼");
set2.add("赖冠霖");
//把set2中的每个元素添加到hashset中
hashSet.addAll(set2);
//元素不能重复 而且无序
System.out.println(hashSet); 3.删除元素
//删除
hashSet.remove("赖冠霖");
// hashSet.clear();//清空容器集合
System.out.println(hashSet);4.修改元素
//修改操作
//判断是否为空
boolean empty = hashSet.isEmpty();
System.out.println(empty);
//判断元素是否在容器中
boolean b = hashSet.contains("夏淼淼");
System.out.println(b);5.hashSet的遍历
1）通过foreach遍历
//遍历--- foreach
for(Object o: hashSet){
System.out.println(o);
}2）通过迭代器来遍历
//迭代器遍历
//获取迭代器对象 有序：有下标
Iterator iterator = hashSet.iterator();
//判断是否指定能够移动
while (iterator.hasNext()){
//指定移动并获取当前的元素
Object next = iterator.next();
System.out.println(next);
}TreeSet集合
TreeSet：基于二叉树，它是一个有序得集合，要求里面得元素必须实现Comparable接口。 按照该接口得方法进行排序以及去重。
TreeSet中的方法和HashSet中的方法一模一样 只是他们的实现不一样。
TreeSet 基于TreeMap 实现。TreeSet可以实现有序集合，但是有序性需要通过比较器实现。
TreeSet举例：
TreeSet treeSet=new TreeSet();
treeSet.add("java05");
treeSet.add("java03");
treeSet.add("java04");
treeSet.add("java01");
treeSet.add("java02");
treeSet.add("java04");
System.out.println(treeSet);存储一个对象类型：
public class Test4 {
public static void main(String[] args) {
TreeSet treeSet=new TreeSet();
treeSet.add(new Student("梁又年",23));
treeSet.add(new Student("夏淼淼",21));
treeSet.add(new Student("赖冠霖",20));
treeSet.add(new Student("蓝小胖",88));
System.out.println(treeSet);
}
}1.在创建TreeSet时，为其指定排序的规则
TreeSet treeSet=new TreeSet();
但是在创建对象时 并没有为其指定排序得规则，那么就要求该集合得元素有排序规则。 如果元素得类已经创建完成，不能修改该类得源码，这时我们又想把该类得对象放入得TreeSet容器中。 这时就需要你在创建TreeSet时指定排序得规则。
public class MyComparator implements Comparator {
//需要比对得两个对象
@Override
public int compare(Object o1, Object o2) {
Student s1= (Student) o1;
Student s2= (Student) o2;
if(s1.getAge()>s2.getAge()){
return 1;
}else if(s1.getAge()<s2.getAge()){
return -1;
}else {
return 0;
}
}
}
public class practice1 {
public static void main(String[] args) {
//Comparator<? super E> comparator
//为TreeSet容器指定了排序规则
TreeSet treeSet=new TreeSet(new MyComparator());
treeSet.add(new Student(23,"梁又年"));
treeSet.add(new Student(21,"夏淼淼"));
treeSet.add(new Student(25,"杨真真"));
treeSet.add(new Student(22,"李影影"));
System.out.println(treeSet);
}
} Map
Map：属于键值对模式。map中得每个元素属于键值对模式。 如果往map中添加元素时 需要添加key 和 value.
它也属于一个接口，该接口常见得实现类有: HashMap.
如何创建Map对象
具体代码如下：
//默认初始化大小为16 负载因子为0.75
Map map=new HashMap();
//初始化大小
Map map2=new HashMap(16);
//初始化大小 负载因子
Map map3=new HashMap(16,0.78f);添加操作
//默认初始化大小为16 负载因子为0.75
Map map=new HashMap();
//添加操作 key: name value: 姓名
//注意: 要求map得key必须唯一。
//因为key不能重复，所以后者会把前者覆盖
map.put("name","温宁");
map.put("age",18);
map.put("name","温琼林");
//把m1中得每个元素 添加到map中
Map m1=new HashMap();
m1.put("k1","v1");
m1.put("k2","v2");
map.putAll(m1);
//如果指定得key存在，则不放入map中，如果不存在则放入map中
map.putIfAbsent("age",28) ;
System.out.println(map);删除操作
//删除操作
//根据指定得key移除元素
map.remove("age2");
System.out.println(map);
//清空map容器
map.clear();
System.out.println(map);修改操作
//修改操作
//替换元素
map.replace("name","温情");
System.out.println(map);查询操作
public static void main(String[] args) {
Map map=new HashMap();
map.put("k1","v1");
map.put("k4","v4");
map.put("k2","v2");
map.put("k3","v3");
//查询操作
//判断map是否存在指定得key
boolean f = map.containsKey("k5");
//根据指定的key获取对应得value值
Object v = map.get("k5");
System.out.println(v);
//返回该map中所有得key
Set keys = map.keySet();
System.out.println(keys);
//遍历map.
for(Object k:keys){
Object value= map.get(k);//
System.out.println(k+"================>"+value);
}
}
扫一扫
408
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
