集合
单列集合
Collection
Collection:是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的。
import java.util.ArrayList;
import java.util.Collection;
public class A01_CollectionDemo1 {
public static void main(String[] args) {
/*
public boolean add(E e) 添加
public void clear() 清空
public boolean remove(E e) 删除
public boolean contains(Object obj) 判断是否包含
public boolean isEmpty() 判断是否为空
public int size() 集合长度
注意点：
Collection是一个接口,我们不能直接创建他的对象。
所以，现在我们学习他的方法时，只能创建他实现类的对象。
实现类：ArrayList
*/
//目的：为了学习Collection接口里面的方法
//自己在做一些练习的时候，还是按照之前的方式去创建对象。
Collection<String> coll=new ArrayList<>();
//1.添加元素
//细节1：如果我们要往List系列集合中添加数据，那么方法永远返回true，因为List系列的是允许元素重复的。
//细节2：如果我们要往Set系列集合中添加数据，如果当前要添加元素不存在，方法返回true，表示添加成功。
// 如果当前要添加的元素已经存在，方法返回false，表示添加失败。
// 因为Set系列的集合不允许重复。
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
System.out.println(coll);
//2.清空
//coll.clear();
//3.删除
//细节1：因为Collection里面定义的是共性的方法，所以此时不能通过索引进行删除。只能通过元素的对象进行删除。
//细节2：方法会有一个布尔类型的返回值，删除成功返回true，删除失败返回false
//如果要删除的元素不存在，就会删除失败。
System.out.println(coll.remove("aaa"));
System.out.println(coll);
//4.判断元素是否包含
//细节：底层是依赖equals方法进行判断是否存在的。
//所以，如果集合中存储的是自定义对象，也想通过contains方法来判断是否包含，那么在javabean类中，一定要重写equals方法。
boolean result1 = coll.contains("bbb");
System.out.println(result1);
//5.判断集合是否为空
boolean result2 = coll.isEmpty();
System.out.println(result2);//false
//6.获取集合的长度
coll.add("ddd");
int size = coll.size();
System.out.println(size);//3
}
}
List系列
List系列的集合：添加的元素有序，可重复，有索引。 有序：存取的顺序。
List继承了Collection接口,有三个实现的类
－ ArrayList
数组列表，数据采用数组方式存储。
－LinkedList
链表
－Vector
数组列表，添加同步锁,线程安全的
ArrayList
ArrayList实现了长度可变的数组，在内存中分配连续的空间。 遍历元素和随机访问元素的效率比较高
常见方法
package javalist.ArrayListDemo;
import java.util.ArrayList;
import java.util.Arrays;
/*add(int index, E element)
get(int index)
indexOf(Object o)
lastIndexOf(Object o)
remove(int index) 删除并返回指定位置元素
removeRange(int fromIndex, int toIndex) 删除指定区间的元素(子类继承使用)
set(int index, E element)*/
public class Demo1 {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList();
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
arrayList.add(4);
arrayList.add(5);
arrayList.add(6);
arrayList.add(7);
arrayList.add(8);
arrayList.add(9);
System.out.println(arrayList.size());
System.out.println(arrayList.contains(1));
System.out.println(arrayList.get(1));
System.out.println(arrayList.remove(8));//索引
System.out.println(Arrays.toString(arrayList.toArray()));//转数组
System.out.println(arrayList.indexOf(3));
//System.out.println(arrayList.);
}
}
集合遍历
package javalist.ArrayListDemo;
import java.util.ArrayList;
import java.util.Iterator;
public class Demo2 {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
list.add("a");
list.add("a");
list.add("c");
list.add("d");
list.add("e");
/* for (int i = 0; i < list.size(); i++) {
if(list.get(i)=="a"){
list.remove(i);
i--;
}
}*/
/* for循环缺点：集合for循环内删除元素，元素会自动前移。
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i)+" ");
} System.out.println();
//加强for循环；不可循环中途删除数据
for (Integer s : list) {
System.out.print(s+" ");
}*/
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
String x=iterator.next();
if(x.equals("a")) {
iterator.remove();
}
}
System.out.println(list);
}
}
LinkedList
LinkedList采用链表存储方式。插入、删除元素时效率比较高
常见方法
package javalist.LinkedListDemo;
import java.util.LinkedList;
public class Demo1 {
public static void main(String[] args) {
LinkedList<Integer> list=new LinkedList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
//indexof:返回指定值第一次出现的索引
//System.ouprintln(list.set(0,0));
/* 在第一位添加，最t.println(list.remove(1));
System.out.后一位取，对列
list.addFirst(0);
list.pollLast();
最后一位进，最后一位取。先进后出，栈。
list.addLast(1);
list.pollLast();
peek:检索不删除
poll:检索并删除*/
System.out.println(list);
}
}
Set系列
Set接口
Set系列集合：添加的元素是无序，不重复，无索引。
● Set接口继承了Collection接口。
Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的
● Set接口有两个实现类
hashSet
HashSet类中的元素不能重复，即彼此调用equals方法比较，都返回false。
底层数据结构是哈希表+链表
哈希表依赖于哈希值存储
常见方法
package javaSet.HashSetDemo;
import java.util.HashMap;
import java.util.HashSet;
public class Demo1 {
public static void main(String[] args) {
HashSet<String> hashSet=new HashSet<>();
hashSet.add("a");
hashSet.add("b");
hashSet.add("b");
//判断重复：先转化为哈希值，相同是在用equals方法比较。
hashSet.add("联通");//
int x="通话".hashCode();
System.out.println(x);
hashSet.add("移动");//
int y="重地".hashCode();
System.out.println(y);
hashSet.add("c");
hashSet.add("d");
hashSet.add("e");
System.out.println(hashSet);
System.out.println();
}
}
TreeSet
● TreeSet 可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。
TreeSet底层数据结构是二叉树(红黑树是一种自平衡的二叉树)
双列集合（ Map）
每次添加一对:键，值
l Map接口概述 将键映射到值的对象 一个映射不能包含重复的键 每个键最多只能映射到一个值
Map接口常用方法
- V put(K key,V value)
- V remove(Object key)
- void clear()
- boolean containsKey(Object key)
- boolean containsValue(Object value)
- boolean isEmpty()
- int size()
- V get(Object key)
- Collection values()
- Set keySet()
- Set<Map.Entry<K,V>> entrySet()
HashMap
HashMap中元素的key值不能重复， 排列顺序是不固定的,可以存储一个 为null的键。
常见方法
package javaMap.MapDemo;
/*
V put(K key,V value)
V remove(Object key)
void clear()
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
int size()
V get(Object key)
Collection<V> values()
Set<K> keySet()
Set<Map.Entry<K,V>> entrySet()
*/
import java.util.*;
public class Demo1 {
public static void main(String[] args) {
Map<String,String> map=new HashMap<>();
map.put("a","a1");
map.put("b","x");
map.put("c","c");
map.put("d","d");
map.put("e","e");
map.put(null,"x");
/* System.out.println(map);
System.out.println(map.remove("a"));//删除
System.out.println(map);
Collection<String > list=map.values();//返回值
System.out.println(list);*/
Set set=map.keySet();//返回键
System.out.println(set);
System.out.println(map.keySet());
/* System.out.println(set);
System.out.println(map.get("b"));//获得键对应的值
System.out.println(map.size());
System.out.println(map.containsKey("b"));
System.out.println(map.containsValue("x"));
System.out.println(map.isEmpty());*/
}
}
遍历
package javaMap.MapDemo;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class HashmapDemo {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("a", "a1");
map.put("b", "x");
map.put("c", "c");
map.put("d", "d");
map.put("e", "e");
//遍历1
Set<String> str=map.keySet();
for (String s : str) {
System.out.println(s+":"+map.get(s));
}
//遍历2
Set<HashMap.Entry<String,String>> S=map.entrySet();
for (Map.Entry<String, String> str1 : S) {
System.out.println(str1.getKey()+":"+str1.getValue());
}
}
}
TreeMap
TreeMap中所有的元素都保持着某种固定的顺序，如果需要得到一个有序
的Map就应该使用TreeMap，key值所在类必须实现Comparable接口。
collections
● Collections是集合类的工具类，与数组的工具类Arrays类似.
package Collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class binarySearchDemo{
public static void main(String[] args) {
ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(1);
list.add(4);
list.add(3);
list.add(5);
Collections.sort(list);
System.out.println(Collections.binarySearch(list, 1));//查询值第一次出现的位子
System.out.println(list);
Collections.swap(list,1,0);//交换指定位置的值
System.out.println(list);
// Collections.emptyList();
/* Collections.fill(list,1);//
System.out.println(list);*/
/* System.out.println(Collections.max(list));
System.out.println(Collections.min(list));*/
/* Collections.replaceAll(list,1,2);//2替换掉集合中的1
System.out.println(list);*/
/* Collections.reverse(list);//逆序输出
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);*/
/*
ArrayList list1=new ArrayList();
list1.add(1);
list1.add(1);
list1.add(1);
list1.add(1);
Collections.copy(list,list1);
System.out.println(list);*/
//System.out.println(Collections.emptyList());//返回一个空列表。
Collections.addAll(list,2,4,5,6,6);//添加元素
System.out.println(list);
System.out.println(ss(1, 2));
}
public static String ss(int...x){
return Arrays.toString(x);
}
}
2980
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
