集合类java ----Java基础篇

最新推荐文章于 2023-10-30 23:24:16 发布

旭日初扬

最新推荐文章于 2023-10-30 23:24:16 发布

阅读量184

点赞数

分类专栏： Java 文章标签： Java集合

Java 专栏收录该内容

129 篇文章 4 订阅

订阅专栏

5.3、List接口的常用实现类有ArrayList与LinkedList

5.4、LinkedList类采用链表结构保存对象

一、集合类概述

1.Java语言的集合类由java.util包提供一部分

2.数据与集合类的异同

集合类与数组不同之处是，数组的长度是固定的，集合的长度是可变的。
数组用来存放基本类型的数据，集合用来存放对象的引用。

3.常用的集合有Map集合，List集合，Set集合，set与List实现Collection接口

二、Collection接口

Collection接口是层次结构中的根接口。
构成Collection的单位，被称之为元素。
Collection接口通常不能直接使用，但该接口提供了添加元素、删除元素、管理数据的方法
collection提供的常用方法

add(E) 将指定对象添加到该集合中
remove(Object) 将指定对象从该集合中移除
isEmpty() 返回boolean值，用于判断当前集合是否为空
iterator()返回在此Collection的元素上进行迭代的迭代器，用于遍历集合中的的对象
size() 返回int类型，获取该集合中元素的个数

三、Collection实例

package com.list.dome;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class ListDome02 {
	public static void main(String []args){
		//实例化集合类对象
		Collection<String> list =new ArrayList<>();
		//添加数据
		list.add("a");
		list.add("b");
		list.add("c");
		//创建迭代器
		Iterator<String> it =list.iterator();
		//判断是否有下一个元素
		while(it.hasNext()){
			//依次获取集合中元素
			String str =(String) it.next();
			System.out.println(str);
		}
		System.out.println("ArryList存在线程不安全的隐患");

}
}

四、Set集合（无序）

1.Set集合中的对象不按特定的方式排序，只是简单地把对象加入集合中，但Set集合中不能包含重复对象

2.Set集合由Set接口和Set接口的实现类组成。Set接口也继承了Collection接口。

3.常用方法

first()返回set的当前第一个元素
last()返回set的当前最后一个元素
comparator()返回对此set中元素进行排序的比较器。
headSet(toElement)返回一个新的set集合，新集合包含toElement(不包含)之前的所有对象
subSet(formElement,fromElement)返回一个新的set集合包哈fromElement(包含)对象与fromElement(不包含)对象之间的所有对象
tailSet(formElement)返回一个新的Set集合，新集合包含对象fromElement(包含)之后的所有对象

import java.util.*;
public class UpdateStu implements Comparable<Object> {
	String name;
	long id;
	public UpdateStu(String name, long id) {
		this.id = id;
		this.name = name;
	}
	//set元素排序比较器compareTo()
	public int compareTo(Object o) {
		UpdateStu upstu = (UpdateStu) o;
		int result = id > upstu.id ? 1 : (id == upstu.id ? 0 : -1);
		return result;
	}
	// id name的set() get()
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public static void main(String[] args) {
		UpdateStu stu1 = new UpdateStu("李同学", 01011);
		UpdateStu stu2 = new UpdateStu("陈同学", 01021);
		UpdateStu stu3 = new UpdateStu("王同学", 01051);
		UpdateStu stu4 = new UpdateStu("马同学", 01012);
		TreeSet<UpdateStu> tree = new TreeSet<>();
		tree.add(stu1);
		tree.add(stu2);
		tree.add(stu3);
		tree.add(stu4);
		Iterator<UpdateStu> it = tree.iterator();
		System.out.println("Set集合中的所有元素：");
		while (it.hasNext()) {
			UpdateStu stu = (UpdateStu) it.next();
			System.out.println(stu.getId() + " " + stu.getName());
		}
		it = tree.headSet(stu2).iterator();
		System.out.println("截取前面部分的集合：");
		while (it.hasNext()) {
			UpdateStu stu = (UpdateStu) it.next();
			System.out.println(stu.getId() + " " + stu.getName());
		}
		it = tree.subSet(stu2, stu3).iterator();
		System.out.println("截取中间部分的集合");
		while (it.hasNext()) {
			UpdateStu stu = (UpdateStu) it.next();
			System.out.println(stu.getId() + " " + stu.getName());
		}
	}
}

import java.util.*;

public class UpdateStu {
	public static void main(String[] args) {
		Map<String,String> map = new HashMap<>(); // 创建Map实例
		map.put("01", "李同学"); // 向集合中添加对象
		map.put("02", "魏同学");
		Set<String> set = map.keySet(); // 构建Map集合中所有key对象的集合
		Iterator<String> it = set.iterator(); // 创建集合迭代器
		System.out.println("key集合中的元素：");
		while (it.hasNext()) { // 遍历集合
			System.out.println(it.next());
		}
		Collection<String> coll = map.values(); 
		// 构建Map集合中所有values值集合
		it = coll.iterator();
		System.out.println("values集合中的元素：");
		while (it.hasNext()) { // 遍历集合
			System.out.println(it.next());
		}
	}
}

五、List集合（有序）

5.1、概述

List接口继承了Collection接口，因此包含Collection中的所有方法
List接口还定义了以下两个非常重要

package com.map.test;


import java.util.LinkedList;
import java.util.List;

public class testList {
	public static void main(String[] args){
		//指定类型为包装类Integer
		List<Integer> list = new LinkedList<>();
		
		for(int i=1;i<100;i++){
			list.add(new Integer(i));
		}
		list.remove(list.get(30));
		
		System.out.println("执行成功");
	}

}

5.2、索引问题

get(int index)：获得指定索引位置的元素。
set(int index , Object obj)：将集合中指定索引位置的对象修改为指定的对象。

package com.map.jar;

public class Emp {
	@SuppressWarnings("unused")  //抑制警告
	private String e_name;
	
	private String e_id;
	
	public String getE_name() {
		return e_name;
	}
	public void setE_name(String e_name) {
		this.e_name = e_name;
	}
	public String getE_id() {
		return e_id;
	}
	public void setE_id(String e_id) {
		this.e_id = e_id;
	}

}

5.3、List接口的常用实现类有ArrayList与LinkedList

ArrayList类实现了可变的数组，允许所有元素，包括null，并可以根据索引位置对集合进行快速的随机访问

缺点：向指定的索引位置插入对象或删除对象的速度较慢

package com.list.dome;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class ListDome02 {
	public static void main(String []args){
		//实例化集合类对象
		Collection<String> list =new ArrayList<>();
		//添加数据
		list.add("a");
		list.add("b");
		list.add("c");
		//创建迭代器
		Iterator<String> it =list.iterator();
		//判断是否有下一个元素
		while(it.hasNext()){
			//依次获取集合中元素
			String str =(String) it.next();
			System.out.println(str);
		}
		System.out.println("ArryList存在线程不安全的隐患");

}
}

package com.list.dome;

import java.util.ArrayList;
import java.util.List;

public class listDeme03 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		List<String> list = new ArrayList<>(); // 创建集合对象
		list.add("a"); // 向集合添加元素
		list.add("b");
		list.add("c");
		int i = (int) (Math.random() * (list.size() - 1)); // 获得0~1之间的随机数
		System.out.println("随机获取数组中的元素：" + list.get(i));
		list.remove(2); // 将指定索引位置的元素从集合中移除
		System.out.println("将索引是'2'的元素从数组移除后，数组中的元素是：");
		for (int j = 0; j < list.size(); j++) { // 循环遍历集合
			System.out.println(list.get(j));
		}
	}

}

5.4、LinkedList类采用链表结构保存对象

优点：便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用LinkedList类实现的List集合的效率较好
缺点：对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较慢

package com.list.dome;

import java.util.LinkedList;

public class listDome01 {
	public static void main(String[] args){
		String a="A",s="S",z="Z",ListTest="LinkdeListTest";
		//实例化linkedlist第一种方式
		LinkedList<String>list = new LinkedList<String>();
		//第二种方式   需要创建接口方能使用
		//collection<String> list = new LinkedList<string>();
		//索引值为0
		list.add(a);
		//索引值为1
		list.add(s);
		//索引值为2
		list.add(z);
		//输出列表中开头（第一个）的对象
		System.out.println(list.getFirst());
		//向列表开头添加一个对象
		list.add(ListTest);
		//再次输出列表中开头的对象，这时输出结果由A变成了LinkdeListTest
		System.out.println(list.getFirst());
		//移除列表中开头的对象
		list.removeFirst();
		//再次获取列表中开头的对象
		System.out.println(list.getFirst());
		System.out.println("-----Java语言区分大小写-------");
		System.out.println("-----list集合存放有序对象--------");
		
	}

}

使用List集合时通常声明为List类型，可通过不同的实现类来实例化集合。

六、Map集合

6.1、概述

Map接口提供了将key映射到值的对象。一个映射不能包含重复的key，每个key最多只能映射到一个值。
Map接口提供集合的常用方法

put(key,value)向集合中添加指定的key与value的映射关系
containsKey(Object key)如果此映射包含指定key的映射关系，则返回TRUE
contains Value(Object value)如果此映射将一个或多个key映射到指定值，则返回TRUE
get(Object key) 如果存在指定的key对象，则返回该对象对应的值，否则返回null
KeySet() 返回该集合中的所有key对象形成的set集合
values() 返回该集合中所有只对象形成的Collection集合

3.Map接口常用的实现类有HashMap和TreeMap。建议使用HashMap类实现Map集合，因为由HashMap类实现的Map集合对于添加和删除映射关系效率更高

4.HashMap是基于哈希表的Map接口的实现，HashMap通过哈希码对其内部的映射关系进行快速查找

5.而TreeMap中的映射关系存在一定的顺序，如果希望Map集合中的对象也存在一定的顺序，应该使用TreeMap类实现Map集合

6.2、实例

Emp类（生成get,set方法）

package com.map.test;

public class Emp {
	
		private String e_name;
		private String e_id;
		//有参数的构造方法
		public Emp(String e_name,String e_id){
			this.e_name=e_name;
			this.e_id=e_id;
			
		}
		//
		public String getE_name() {
			return e_name;
		}
		public void setE_name(String e_name) {
			this.e_name = e_name;
		}
		public String getE_id() {
			return e_id;
		}
		public void setE_id(String e_id) {
			this.e_id = e_id;
		}

	}

测试类（Text.java）

package com.map.test;

import java.util.Map;
import java.util.TreeMap;

public class Test {
	public static void main(String[] args){
		//使map接口有一定的顺序，使用实现类TreeMap实现map接口，实例化一个TreeMap实现类
		Map<String,String> map = new TreeMap<>();
		//创建e_id,e_name的映射关系
		Emp emp1 = new Emp("001","张三");
		Emp emp2 = new Emp("002","王五");
		Emp emp3 = new Emp("005","赵四");
		Emp emp4 = new Emp("009","黎六");
		Emp emp5 = new Emp("010","欧奇");
	//把映射关系(键值对)添加到TreeMap集合类中
		map.put(emp1.getE_id(),emp1.getE_name());
		map.put(emp2.getE_id(),emp2.getE_name());
		map.put(emp3.getE_id(),emp3.getE_name());
		map.put(emp4.getE_id(),emp4.getE_name());
		map.put(emp5.getE_id(),emp5.getE_name());
	//从集合中移除e_id为010的映射关系
		map.remove("010");
		//遍历集合返回key
		for(String string : map.keySet()){
		System.out.println(map.get(string));
	}
	}

}

6.3、遍历map集合常用的四种方式

数据准备

package com.map.test;

public class Emp {
	
		private String e_name;
		private String e_id;
		//有参数的构造方法
		public Emp(String e_name,String e_id){
			this.e_name=e_name;
			this.e_id=e_id;
			
		}
		//
		public String getE_name() {
			return e_name;
		}
		public void setE_name(String e_name) {
			this.e_name = e_name;
		}
		public String getE_id() {
			return e_id;
		}
		public void setE_id(String e_id) {
			this.e_id = e_id;
		}

	}

package com.map.jar;

import java.util.HashMap;
import java.util.Map;

public class TestMap {
	public static void main(String[] args){
	  //实现Map接口的第一种实现类TreeMap,有序
     //Map<String,String> map =new TreeMap();
    //实现接口的第二种实现类HashMap,通过哈希码对
//Map<String,String> map =new HashMap();
Map<String,String> map =new HashMap<String,String>();
       
//创建e_id,e_name的映射关系
		Emp emp1 = new Emp("001","张三");
		Emp emp2 = new Emp("002","王五");
		Emp emp3 = new Emp("005","赵四");
		Emp emp4 = new Emp("009","黎六");
		Emp emp5 = new Emp("010","欧奇");
	//把映射关系(键值对)添加到TreeMap集合类中
		map.put(emp1.getE_id(),emp1.getE_name());
		map.put(emp2.getE_id(),emp2.getE_name());
		map.put(emp3.getE_id(),emp3.getE_name());
		map.put(emp4.getE_id(),emp4.getE_name());
		map.put(emp5.getE_id(),emp5.getE_name());

	}

}

遍历方式一：二次取值常用通过map.keySet遍历key可value

for(String string:map.keySet()){
System.out.println("key="+string+"vaule="+map.get(string));
	System.out.println("第一种方式：通过map.keySet遍历key和value");
	}

遍历方式二：通过Map.entrySet使用迭代器（iterator）遍历key和value

Iterator<Map.Entry<String,String>> it=map.entrySet().iterator();
		while(it.hasNext()){
			Map.Entry<String, String>entry=it.next();
			System.out.println("key="+entry.getKey()+"value="+entry.getValue());
		}

遍历方式三：集合容量大时使用推荐使用，通过entry.setKey遍历key和value

for(Map.Entry<String,String>entry:map.entrySet()){
	System.out.println("key="+entry.getKey()+"value="+entry.getValue());
}

遍历方式四：通过map.value遍历所有value但不能遍历key

for(String value:map.values()){
	System.out.println("value="+value);
	
}

旭日初扬

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合类java ----Java基础篇

目录一、集合类概述二、Collection接口三、Collection实例四、Set集合（无序）五、List集合（有序）5.1、概述5.2、索引问题 5.3、List接口的常用实现类有ArrayList与LinkedList5.4、LinkedList类采用链表结构保存对象六、Map集合6.1、概述6.2、实例6.3、遍历map集合常...
复制链接

扫一扫