Java中的集合就像是一个容器，专门来存储Java对象，这些对象可以是任意的数据类型，长度可变，集合按照其储存结构可以分为俩大类，即单列集合Collection和双列集合Map Collection:单列集合的根接口，用来存储一系列符合某种规则的元素。Collection有俩个重要的子接口，分别是Set和List。其中Set接口的特点是无序并且不可重复，List接口的特点是有序可重复。List的主要实现类有ArrayList和LinkedList；Set接口的主要实现类是HashSet和TreeSet Map:双列集合的根接口，用于存储KV键值对，在Map存储的元素中，每个元素都有一个K，并且K是唯一的，可以通过指定的K来找到对应的V。Map的主要实现类是HashMap和TreeMap 用一张图来描述集合的核心继承体系 Collection是所有单例集合的根接口，因此Collection中定义了一些通用方法，这些方法可用于操作所有的单列集合
List是单列集合的一个重要分支，在List集合中允许出现重复的元素，可以通过索引来访问指定的元素，List集合还有一个特点就是，有序的，即存入顺序和去出顺序一致，List作为Collection的子接口，不仅继承了他的全部方法，还有一些自己独有的方法
ArrayList是List接口的一个实现类，在ArrayList类封装了一个长度可变的数组对象，当存入的元素超过数组的长度时，ArrayList会自动生成一个更大的数组来存储元素，因此，可以将ArrayList看作是一个长度可变的数组对象，正因为ArrayList的底层是数组，所以他的增删效率低，但是查找的效率高 public class ArrayListTest {
public static void main(String[] args) {
//创建ArrayList集合
List list = new ArrayList();
//添加元素
list.add("a");
list.add("b");
list.add(3);
System.out.println("ArrayList集合的长度是:"+list.size());
System.out.println("ArrayList集合的第二个元素是:"+list.get(1));
}
}
ArrayList的增删效率较低，为了克服这种局限性，可以使用List的另一个实现类LinkedList，他的底层是一个双向链表，链表中的每一个元素都有引用指向它的前一个和后一个元素，当要对元素进行修改时，只需要更改元素之间的引用关系就好了，大大提高了增删的效率 LinkedList的常用方法 import java.util.LinkedList;
public class LinkedListTest {
public static void main(String[] args) {
//创建一个LinkedList集合
LinkedList list = new LinkedList();
//增加元素
list.add(1);
list.add("2");
//输出集合中的元素
System.out.println(list);
//向集合尾部添加元素
list.offer("offer");
//向头部添加元素
list.push("push");
//输出元素
System.out.println(list);
//获取第一个元素
Object obj = list.peek();
//输出元素
System.out.println(obj);
//删除第一个元素
list.removeFirst();
list.pollLast();
//删除最后一个元素
}
}
Iterator和Collection、Map不同，后俩者主要是用来存储元素，而前者主要是用来遍历元素的，因此他被称为迭代器 import java.util.ArrayList;
import java.util.Iterator;
public class IteratorTest {
public static void main(String[] args) {
//1、创建集合并且添加元素
ArrayList arrayList = new ArrayList();
arrayList.add(1);
arrayList.add(2);
arrayList.add("3");
arrayList.add("4");
//获取Iterator对象
Iterator it = arrayList.iterator();
//判断是否有下一个元素的存在
while(it.hasNext()){
System.out.println(it.next());
}
}
}
import java.util.ArrayList;
public class foreachTest {
public static void main(String[] args) {
//1、创建集合并且添加元素
ArrayList arrayList = new ArrayList();
arrayList.add(1);
arrayList.add(2);
arrayList.add("3");
arrayList.add("4");
//遍历
for (Object obj : arrayList){
System.out.println(obj);
}
}
}
Set继承自Collection接口，他并没有功能上的扩充，只是比Collection更加的严格。Set接口中的元素无序并且不可重复 HashSet是Set接口的一个实现类，他存储的元素是不可重复的，并且也是无序的 public class HashSetTest {
public static void main(String[] args) {
//创建HashSet并且添加元素
HashSet hashSet = new HashSet();
hashSet.add("JACK");
hashSet.add("king");
hashSet.add("Rose");
//遍历集合
Iterator iterator = hashSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
king
Rose
JACK
向HashSet存入自定义的Student类，并且规定id和姓名一样即为相同元素 import java.util.HashSet;
import java.util.Objects;
public class HashSetTest02 {
public static void main(String[] args) {
Students stu1 = new Students("1","KING");
Students stu2 = new Students("1","ROSE");
Students stu3 = new Students("2","ROSE");
Students stu4 = new Students("2","ROSE");
HashSet hashSet = new HashSet();
hashSet.add(stu1);
hashSet.add(stu2);
hashSet.add(stu3);
hashSet.add(stu4);
System.out.println(hashSet);
}
}
class Students{
String id;
String name;
public Students(String id,String name){
this.name = name;
this.id = id;
}
//重写toString方法
@Override
public String toString() {
return "Students{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
'}';
}
//重写equals方法，规定id和姓名全一样才为重复数据
public boolean equals(Object obj){
if (this==obj){
return true;
}
if (!(obj instanceof Students)){
return false;
}
Students students =(Students)obj;
boolean b = (this.id.equals(students.id)&&this.name.equals(students.name));
return b;
}
//重写HashCode方法
@Override
public int hashCode() {
return Objects.hash(id);
}
}
[Students{id='1', name='KING'}, Students{id='1', name='ROSE'}, Students{id='2', name='ROSE'}]
TreeSet他的内部是用二叉树来存储数据的，这样的结构不仅保证了没有重复的数据，而且还有一定的顺序。二叉树就是每个节点最多有俩个节点的有序树，并且他的左子树上的元素小于他的根节点，右子树上的元素大于他的根节点 用于TreeSet存储元素的特殊性，它有一些特殊的方法 import java.util.TreeSet;
public class TreeSetTest {
public static void main(String[] args) {
//创建TreeSet集合
TreeSet treeSet = new TreeSet();
//添加元素
treeSet.add(3);
treeSet.add(7);
treeSet.add(9);
treeSet.add(11);
System.out.println("创建的TreeSet集合为:"+treeSet);
//获取首尾元素
System.out.println("TreeSet的首元素是:"+treeSet.first());
System.out.println("TreeSet的尾元素是:"+treeSet.last());
//比较并且获取元素
System.out.println("获取集合中小于或等于8的最大的一个元素:"+treeSet.floor(8));
System.out.println("获取集合中大于10的最小的一个元素:"+treeSet.higher(10));
//元素的删除
//删除第一个元素
treeSet.pollFirst();
}
}
Map接口是一种双列集合，他的每个元素都包含一个KV键值对，K和V之间存在一种对应关系。Map中的映射关系是一一对应的。可以通过key来找到V Map集合中常用方法 HashMap是Map接口的一个实现类，该集合的键值对允许为空，但键不可以重复，并且集合中的元素是无序的。HashMap的底层是哈希表组成的 public class HashMapTest {
public static void main(String[] args) {
//创建HashMap
HashMap map = new HashMap();
//添加元素
map.put("1","Jack");
map.put("2","King");
map.put("3","Rose");
map.put("1","Lucy");
map.put("2","Tom");
System.out.println(map);
//查看键对象是否存在
System.out.println(map.containsKey("1"));
//获取指定key的值
System.out.println(map.get("2"));
//获取集合中的键对象和值对象
System.out.println(map.keySet());
System.out.println(map.values());
//替换对象
map.replace("3","Mike");
//删除指定k的值
map.remove("2");
}
}
使用Iterator迭代器遍历Map集合，需要先将Map集合转换成Iterator对象，任何进行遍历，由于Map集合是由键值对组成的，所以有俩中将Map转换成Iterotor的方法，即keySet()方法和entrySet()方法 public class IteratorKeySetTest {
public static void main(String[] args) {
//创建HashMap
HashMap map = new HashMap();
//添加元素
map.put("1","Jack");
map.put("2","King");
map.put("3","Rose");
map.put("4","Lucy");
map.put("5","Tom");
//获取键的集合
Set set = map.keySet();
//迭代器
Iterator iterator = set.iterator();
while (iterator.hasNext()){
Object key = iterator.next();
Object value =map.get(key);
System.out.println(key+":"+value);
}
}
}
public class IteratorEntryTest {
public static void main(String[] args) {
//创建HashMap
HashMap map = new HashMap();
//添加元素
map.put("1","Jack");
map.put("2","King");
map.put("3","Rose");
map.put("4","Lucy");
map.put("5","Tom");
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()){
Map.Entry entry = (Map.Entry)(iterator.next());
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key+":"+value);
}
}
}
TreeSet也是用来存储简直映射关系的，并且不允许出现重复的值,并且按一定的规程排序 public class TreeMapTest {
public static void main(String[] args) {
Map map = new TreeMap();
map.put("1","Jack");
map.put("2","King");
map.put("3","Rose");
map.put("4","Lucy");
map.put("5","Tom");
System.out.println(map);
}
}
{1=Jack, 2=King, 3=Rose, 4=Lucy, 5=Tom}
Properties是键值对都是Strinf类型的集合，一般用于存储属性，因此也称为属性集合 import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class PropertiesTest {
public static void main(String[] args) throws IOException {
//通过Properties进行属性文件的读取操作
Properties properties = new Properties();
//加载文件
properties.load(new FileInputStream("test.properties"));
//遍历
Set entrySet = properties.entrySet();
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry) (iterator.next());
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key + "=" + value);
}
//写入操作
FileOutputStream fileOutputStream = new FileOutputStream("test.properties");
properties.setProperty("password", "123");
properties.store(fileOutputStream,"新增密码");
}
}
//具体格式
ArrayList<参数类型>list = new ArrayList<参数类型>();
import java.util.ArrayList;
public class 泛型 {
public static void main(String[] args) {
//创建ArrayList类型的集合，并且设置只可以存储String类型\
ArrayList<String>list = new ArrayList<>();
list.add("String");
list.add("Collection");
for (String s:list){
System.out.println(s);
}
}
}
扫一扫
423
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
