Java集合类

最新推荐文章于 2024-10-10 09:56:47 发布

猿徐

最新推荐文章于 2024-10-10 09:56:47 发布

阅读量87

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/negel_xu/article/details/112508196

版权

java 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

1. 先聊数组

数组：类型相同、大小固定的很多数组成在一起
优点：类型相同
缺点：大小固定

2. 集合

集合：类型多样，大小可变的很多数集中合在一起
优点：大小可变
缺点：类型多样

3. 集合+泛型

优点：大小可变
优点：类型相同
泛型就是一个< >
- 我们把泛型理解成规范的一个类型
- 放进和取出都只能是一种类型，且不需要再判断

4. 集合框架(常用集合接口和实现类)

						Collection(I)-->obj					 Map(I)-->key-value							

			List(I)					Set(I)

ArrayList (Vector) HashSet HashMap (HashTable)

LinkedList TreeSet TreeMap

其它类

Stack
Queue
Properties

5. List接口 (有序,可重复，可null)

5.1. ArrayList 是数组形式的集合

数组形式：存储空间是连续的。
- 查询和修改的效率高
- 插入和删除的效率低
特点:
- 有序、可重复、可null
常用方法:
- add()
- get()
- size()
- iterator()
- toArray()

示例

ArrayList lst = new ArrayList();
		
// 装箱   值==>引用
lst.add(1); // new Integer(1)
lst.add(5);
lst.add(7);
lst.add(3);
lst.add("bb");
lst.add("aa");
lst.add(1);
lst.add(null);

//集合大小
System.out.println(lst.size());

//获取第1个
Integer i = (Integer) lst.get(0);
System.out.println(i);
//获取倒数第2个
Integer i2= (Integer) lst.get(lst.size()-2);
System.out.println(i2);

//第一个插入QQ
lst.add(0, "qq");

//删除第一个(通过下标)
lst.remove(0);

//第一个插入QQ
lst.add(0,new String("qq"));
//删除第一个(通过值)
lst.remove(new String("qq"));

//修改倒数第二个为11
lst.set(lst.size()-2, 11);

//打印一
System.out.println(lst.toString());

//遍历二
for(int j=0;j<lst.size();j++) {
    System.out.print(lst.get(j)+"\t");
}
System.out.println();

//遍历三
for(Object item :lst) {
    System.out.print(item+"\t");
}
System.out.println();

//遍历四
Iterator it = lst.iterator();
while(it.hasNext()) {
    System.out.print(it.next()+"\t");
}

ArrayList存储一组用户录入数值，使用冒泡对它进行排序
ArrayList，加入三个学生,通过toArray()转成数组，
- 调用sort(List)实现排序，此时会报学生没有可比性，要让学生类具有可比性，要实现Comparable接口的compareTo(Student stu)的就去即可
- 下面的方式破坏了Student类本身，还可以调用 sort(List,Comparator)的方法，学生类不变，加上一个比较器即器，比较器需要自己实现。一般实现Comparator的接口即可
学生管理系统，使用ArrayList实现

5.2. Vector : 线程安全的

几乎与ArrayList一样,但是线程安全的，之前使用较用，又称历史集合类
ArrayList是线程不安全，效率高。在线程中也可以使用ArrayList
```
 List lst =Collections.synchronizedList(arrayList);
```
历史集合类多了一种遍历方式 Enumeration的方式

示例

Vector lst = new Vector();
lst.add(1);
lst.add(11);
lst.add(5);
lst.add(6);
lst.add(3);
lst.add(1);
lst.add(null);

//lst.addAll(index, c);
//lst.remove(index);

//打印一
System.out.println(lst);

//遍历二
for(int i=0;i<lst.size();i++) {
    System.out.print(lst.get(i)+"\t");
}
System.out.println();

//遍历三
for(Object obj:lst) {
    System.out.print(obj+"\t");
}
System.out.println();

//遍历四
Iterator<Object> i = lst.iterator();
while(i.hasNext()) {
    System.out.print(i.next()+"\t");
}
System.out.println();

//遍历五
Enumeration<Object> e = lst.elements();
while(e.hasMoreElements()) {
    System.out.print(e.nextElement()+"\t");
}
System.out.println();

5.3. LinkedList

底层采用的是链接结构进存储的集合
- 增加和删除效率高
- 查询和修改效率低
特点：
- 有序、可重、可null
常用方法
- add()
- addFirst()
- addLast()
- remove()
- removeFirst()
- removeLast()
- add(index,Object)
- set(indec,Object)
- iterator()
- toArray()

示例

LinkedList lst = new LinkedList<>();
lst.add(23);
lst.add(5);
lst.add(null);
lst.add("bb");
lst.add("aa");
lst.add(1);
lst.add(5);

lst.addFirst("qq");
//lst.add(index, element);
//lst.removeFirst();
//lst.remove(index)

//打印一
System.out.println(lst);

//遍历二
for(int j=0;j<lst.size();j++) {
    System.out.print(lst.get(j)+"\t");
}
System.out.println();

//遍历三
for(Object item :lst) {
    System.out.print(item+"\t");
}
System.out.println();

//遍历四
Iterator it = lst.iterator();
while(it.hasNext()) {
    System.out.print(it.next()+"\t");
}

6. Set接口（无序，不可重复）

6.1. HashSet

底层由由哈希表支持的，存储的元素是无序且不能重复的
特点:
- 无序、不可重复、可一个null
- 不可重复的标准
  - 先比hashCode(),如果hashCode()不相等，则直接认为不重复；否则再判断equals()，如果equals()也相等，则认为重复，反之不重复。
  - 再比对象equals()
常用方法:
- add()
- size()
- remove()
- iterator()

示例

public static void main(String[] args) {
    HashSet set = new HashSet<>();

    set.add("aa");
    set.add("cc");
    set.add("bb");
    set.add(22);
    set.add(11);
    set.add(44);
    set.add(33);

    set.add(null);
    set.add(11);


    //插 没有
    //删除
    set.remove(null);

    //打印一
    System.out.println(set);
    //打印二 for加强
    for(Object obj :set) {
        System.out.print(obj+"\t");
    }
    System.out.println();
    //打印三 iterator
    Iterator<Object> i = set.iterator();
    while(i.hasNext()) {
        System.out.print(i.next()+"\t");
    }
    System.out.println();
}

public static void main(String[] args) {
		HashSet<Student> stus = new HashSet<>();
		stus.add(new Student(1, new String("a"), 18, "男","南京")); //hashCode() 
		stus.add(new Student(1, new String("a"), 18, "男","南京")); //hashCode()
		stus.add(new Student(3, "b", 18, "男","南京")); //hashCode() 
		System.out.println(stus.size());//1
		System.out.println(stus);
		
		HashSet<String> names = new HashSet<>();
		names.add(new String("aa"));
		names.add(new String("aa"));
		System.out.println(names.size()); //1
		System.out.println(names);
	}

package net.wanho.vo;


public class Student   {
	private int id;
	private String name;
	private int age;
	private String gender;
	private String address;
	
	public Student() {
		super();
	}

	public Student(int id, String name, int age, String gender, String address) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.address = address;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + ", address=" + address
				+ "]";
	}
	
	@Override
	public int hashCode() {
		System.out.println("hashCode...");
		return id+name.hashCode();
	}
	
	@Override
	public boolean equals(Object obj) {
		System.out.println("equals....");
		Student stu = (Student) obj;
		return this.id==stu.id && this.name.equals(stu.name);
	}
}

6.2. TreeSet

底层: 使用元素的自然顺序对元素进行排序，前提TreeSet中的元素具有可比性
特点:
- 一般TreeSet使用中，都加上泛型，因为排序。不同类型，无法排序，打印时报错
- 排序、不可重复、不可null
  - 加入内容时会调用元素的compareTo()方法，所以不能加null
- 不可重复的标准:
  - 比较的是对象的compareTo( )方法，返回0则认为重复，否则不重复
- 排序的标准
  - compareTo( )方法的结果
    - 大于返回正数，小于返回负数，等于0，则为升序
    - 大于返回负数，小于返回正数，等于0，则为降序
常用方法:
- add()
- size()
- iterator()
- remove()

示例

TreeSet set = new TreeSet<>();
		
/*set.add("ab");
		set.add("aa");
		set.add("dd");
		set.add("bb");*/

set.add(33);
set.add(11);
set.add(22);
set.add(44);
set.add(11);

set.remove(22);

//set.add(null);


System.out.println(set);

for(Object obj :set) {
    System.out.print(obj+"\t");
}
System.out.println();

Iterator<Object> i = set.iterator();
while(i.hasNext()) {
    System.out.print(i.next()+"\t");
}
System.out.println();

TreeSet<Student> stus = new TreeSet<>();
//元素具有可比性
stus.add(new Student(1, new String("aa"), 18, "男","南京"));  
stus.add(new Student(1, new String("aa"), 18, "男","南京")); 

System.out.println(stus);//1

package net.wanho.vo;


public class Student  implements Comparable<Student> {
	private int id;
	private String name;
	private int age;
	private String gender;
	private String address;
	
	public Student() {
		super();
	}

	public Student(int id, String name, int age, String gender, String address) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.address = address;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + ", address=" + address
				+ "]";
	}
	

	@Override
	public int compareTo(Student stu) {
		System.out.println("compareTo...");
		if(this.id>stu.id) {
			return 1;
		}else if(this.id<stu.id){
			return -1;
		}else {
			return this.name.compareTo(stu.name);
		}
	}

	
	
}

7. Map接口(放置的是键值对对象)

7.1. HashMap

键底层由由哈希表支持的，存储的元素是无序且不能重复的，值没有要求，随便放置对象
特点:
- 键：无序、不可重复、可一个null
- 键：不可重复的标准
  - 先比hashCode(),如果hashCode()不相等，则直接认为不重复；否则再判断equals()，如果equals()也相等，则认为重复，反之不重复。
  - 再比对象equals()
- 线程不安全
常用方法:
- put(k,v)
- get(k)
- Set keys()
- Collection values()
- Set<Entry<Ojbect,Object>> entrySet()
- size()

示例

HashMap map = new HashMap<>();
		map.put(3, "aa");
		map.put(1, "aa");
		map.put(2, "aa");
		map.put(1, "aaa");
		map.put(null, null);
		map.put("mm", "mm");
		
		//add or update
		map.put(1, "aaaa");
		//get
		System.out.println(map.get(1)); //aaaa
		//remove
		map.remove(1);
		
		//打印一
		System.out.println(map);
		//打印二 //map.values();
		Set<Object> keys = map.keySet();
		for(Object key :keys) {
			System.out.print(key+"-"+map.get(key)+"\t");
		}
		System.out.println();
		// 打印三:
		Set<Object> keys2 = map.keySet();
		Iterator<Object> i = keys.iterator();
		Object key;
		while(i.hasNext()) {
			key = i.next();
			System.out.print(key+"-"+map.get(key)+"\t");
		}
		System.out.println();
		
		//打印四: 直接取键值 Entry<Object,Object>
		Set<Entry<Object,Object>> sets = map.entrySet();
		for(Entry<Object,Object> kv:sets ) {
			System.out.print(kv.getKey()+"-"+kv.getValue()+"\t");
		}
		System.out.println();
		
		System.out.println(map.size());

public static void main(String[] args) {
		HashMap<Integer, Student> stuMap = new HashMap<>();
		Student stu1 = new Student(1, "张三", 18, "男", "南京");
		Student stu2 = new Student(2, "张三", 18, "男", "南京");
		Student stu3 = new Student(3, "张三", 18, "男", "南京");

		stuMap.put(stu1.getId(), stu1);
		stuMap.put(stu2.getId(), stu2);
		stuMap.put(stu3.getId(), stu3);

		System.out.println(stuMap);

		HashMap<Student, Integer> idMap = new HashMap<>();
		idMap.put(stu1, stu1.getId()); // hashCode()
		idMap.put(stu2, stu2.getId()); // hashCode()
		idMap.put(stu3, stu3.getId());	// hashCode()
		System.out.println(idMap);
	}

7.2. HashTable

键底层由由哈希表支持的，存储的元素是无序且不能重复的，值也不能为null
特点:
- 键：无序、不可重复、不可null
- 键：不可重复的标准
  - 先比hashCode(),如果hashCode()不相等，则直接认为不重复；否则再判断equals()，如果equals()也相等，则认为重复，反之不重复。
  - 再比对象equals()
- 线程安全
常用方法:
- - put(k,v)
  - get(k)
  - Set keys()
  - Collection values()
  - Set<Entry<Ojbect,Object>> entrySet()
  - size()
  - Enumeration elements() 返回值的枚举

示例

public static void main(String[] args) {
    Hashtable map = new Hashtable<>();
    map.put(3, "aa");
    map.put(1, "aa");
    map.put(2, "aa");
    map.put(1, "aaa");
    //map.put(null, "nnn");
    //map.put(5, null);
    map.put("mm", "mm");

    System.out.println(map);

    Enumeration<Object> values = map.elements();
    while(values.hasMoreElements()) {
        System.out.print(values.nextElement()+"\t");
    }
}

7.3. TreeMap

底层: 键: 使用元素的自然顺序对元素进行排序，前提TreeSet中的元素具有可比性
特点:
- 一般TreeMap使用中，键都加上泛型，因为排序。不同类型，无法排序，打印时报错
- 键：排序、不可重复、不可null
  - 加入内容时会调用键元素的compareTo()方法，所以不能加null
- 键不可重复的标准:
  - 比较的是键对象的compareTo( )方法，返回0则认为重复，否则不重复
- 排序的标准
  - compareTo( )方法的结果
    - 大于返回正数，小于返回负数，等于0，则为升序
    - 大于返回负数，小于返回正数，等于0，则为降序
- 值没有约束
常用方法:
- add()
- size()
- iterator()
- remove()
- entry()

8. Properties类,它是HashTable的子类

介绍
- Properties是一个集合框架实现类，它是HashTable的子类，HashTable具有特征它都有。但它额外核心功能是加载文件流
- 把文件中的内容填充到Properties集合中去，对文件进行逐行读取，把行等号前作为键，等号后作为值，需要注意的等号前后不要留空格
常用方法
- put()
- entrySet()
- keySet()
- elements()
- getProperty(key)
- load(inputStream)
补方法：读文件流的方法
- InputStream 类.class.getClassLoader().getResourceAsStream(“文件名”)===>bin/文件名【推荐】
- InputStream 类.class.getResourceAsStream(“文件名”==>bin/包1/包2/文件名

示例

Properties p = new Properties();
		p.put("driver", "com.mysql.jdbc");
		p.put("url", "http://jdbc:mysql://localhost:3306");
		p.put("username","root");
		p.put("password","123456");
		
		System.out.println(p);

//找文件  //Properties2.class.getClassLoader()==>bin/db.properties
		InputStream is = Properties2.class.getClassLoader().getResourceAsStream("db.properties");
		// //Properties2.class==>bin/net/wanho/other/db.properties
		//InputStream is = Properties2.class.getResourceAsStream("db.properties");
		
		Properties p = new Properties();
		p.load(is); //读取文件，遍历行，每行=前作key,=后作值
		
		System.out.println(p);
		String username = p.getProperty("username");
		System.out.println(username);

src/db.properties

driver=com.mysql.jdbc
url=http://jdbc:mysql://localhost:3306
username=wanho
password=123456

9. Stack与Queue

9.1. Stack (LIFO)(FILO) ，它是Vector的子类

特征
- 存放一个Object
- 反序、可重复、可null
方法:
- add()
- add(index,object)
- push()
- remove(index)
- remove(object)
- iterator()
- elements()
- peek()
- pop()

示例

//反序、可null可重复
Stack s = new Stack<>();
s.add(1);
s.add(3);
s.add(9);
s.add(5);
s.add(2);
s.add(1);
s.add(null);
s.push("ok");

System.out.println(s);

for(Object obj:s) {
    System.out.print(obj+"\t");
}
System.out.println();

//System.out.println(s.pop());//ok
//System.out.println(s.peek());//null

while(s.size()!=0) {
    System.out.print(s.pop()+"\t");
}

//System.out.println(s.size());

9.2. Queue (LILO)(FIFO)

特点
- 它是一个接口，有个实现子类 LinkedList
- 有序，可重复，可null
常用方法
- peek()
- poll()

Queue<Integer> q = new LinkedList<Integer>();
q.add(1);
q.add(12);
q.add(13);
q.add(1);
q.add(null);

System.out.println(q);

while(q.size()!=0) {
    System.out.println(q.poll());
}

10. Collections类

专门操作集合的类
常用方法
- sort(List) 排序
- swap(List,int,int) 交换
- shuffle(List) 乱序
- addAll(Collection) 加另一集合所有元素
- reverse() 反序
- max()
- min()
- emptySet()
- emptyList()
- emptyMap()
- synchronizedList(List)
- synchronizedSet(Set)
- synchronizedMap(Map)

11. 代码调试

代码运行有两个模式
- 运行模式（ctrl+F11）：直接运行完main方法，但是代码流程中遇到断点不会停止
- 调用模式 (F11) : 运行完main方法，但是代码流程中遇到断点会停止
断点的使用
- 加入断点在代码行前双击或右击(toogle breakpoint)
- 移除断点在代码行前再双击或右击(toogle breakpoint)
使用调用的快捷键
- F8 在停止位置继续执行，如果有断点继续停止到下一个断点，如果没有断点程序运行结束
- F5 : 步进
- F6：步过
- F7 : 步回
debug perspective
- 能查看变量的值
- 在调试模式中，选择变量，右击watch查看express perspective

12. 包:

功能
- 避免类名冲突
- 代码条理性
特点：
- 包名全小写
- 包名一般公司域名的倒写+模块名
语法
- 打包:
  
  package 包1.包2; 放置源码的最上面
- 导包
  
  import 包1.包2.类; 放置源码的最上面，但要在打包的下面
  
  当有访问级别，但不在同一个包中类，就需要导入此类所在的包.类，这样就可以在当前类中使用了
常用包

lang 常用类如:String 、System和Object 。此包在java中默认导入

util 工具类如: Date、Scanner、Randmon 和集合框架

io 文件操作类

jdbc 数据库操作

reflect 反射

13. 作业

ArrayList 版的学生管理
调试一定要熟练
HashMap<Integer,Student> 版学生管理
作业1：
使用ArrayList集合，对其添加100个不同的元素：
1.使用add()方法将元素添加到ArrayList集合对象中；
2.调用集合的iterator()方法获得Iterator对象，并调用Iterator的hasNext()和next()方法，迭代的读取集合中的每个元素；
3.调用get()方法先后读取索引位置为50和102的元素，要求使用try-catch结构处理下标越界异常
作业2：
选择某种Map集合保存学号从1到15的学员的学号（键）和姓名（值），学号用字符串表示，输入的时候要以学号乱序的方式存入Map集合，然后按照学号从大到小的顺序将Map集合中的元素输出打印。需要自定义Map集合的比较器Comparator，因字符串对象的大小比较是按字典序，而非对应的数值。
要求：必须使用Map集合的内部排序机制进行排序，不能在外部排序。