Java第九天笔记01——集合1

最新推荐文章于 2024-10-17 10:27:13 发布
最新推荐文章于 2024-10-17 10:27:13 发布
阅读量358 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43861647/article/details/122497173
版权

目录

1.Java集合概念

2.Java中数组与集合的比较

3.Java中集合框架层次结构

4.Collection接口

4.Iterator接口

5.迭代器模式（重点）

6.Collections类

7.自定义比较器（重点）

1.Java集合概念

  • Java中集合类是用来存放对象的
  • 集合相当于一个容器，里面包容着一组对象 —— 容器类
  • 其中的每个对象作为集合的一个元素出现

2.Java中数组与集合的比较

  • 数组也是容器，它是定长的，访问较快，但是数组不会自动扩充
  • 数组可以包含基本数据类型或引用类型的对象，而集合中只能包含引用类型的对象

3.Java中集合框架层次结构

 

4.Collection接口

①一组称为元素的对象
②一个Collection中可以放不同类型的数据
③是Set接口和List接口的父类
④是否有特定的顺序以及是否允许重复，取决于它的实现

  • Set － 无序的集合；不允许重复
  • List － 有序的集合；允许重复

（1）List接口

用来包含一组有序有重复的对象

 List有两种主要的集合实现类：

  • ArrayList — ArrayList是线性顺序存储的，是一种线性表
  • LinkedList — 相对于List来说，LinkedList最主要的功能方面的增强是可以在List的头部和尾部添加、删除、取得元素，直接提供了这些方法的实现。所以它可以非常方便的实现我们数据结构中的常见的Stack(栈)、queue(队列)等

 常见方法：

LinkedList增加的方法：

例子：

package test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

public class Test {
	public static void main(String[] args) {
		//<>:砖石运算符，用于指定集合类型
		ArrayList<String> arrayList = new ArrayList<>();//创建ArrayList集合
		LinkedList<String> linkedList = new LinkedList<>();//创建LinkedList集合
		
		//给ArrayList集合添加元素
		arrayList.add("string1");
		arrayList.add("string2");
		arrayList.add("string3");
		arrayList.add("string4");
		arrayList.add("string5");
		arrayList.add("string5");
		arrayList.add(null);
		System.out.println(arrayList.toString());//[string1, string2, string3, string4, string5, string5, null]
		System.out.println(arrayList.indexOf("string5"));//4
		System.out.println(arrayList.lastIndexOf("string5"));//5
		arrayList.remove(arrayList.size() - 1);//移除最后一个元素
		arrayList.set(5, "string6");//替换索引为5的元素
		System.out.println(arrayList.toString());//[string1, string2, string3, string4, string5, string6]
		Iterator<String> iterator = arrayList.iterator();//返回集合中元素的列表迭代器
		while(iterator.hasNext()){//遍历迭代器
			System.out.print(iterator.next() + "  ");  
			//string1  string2  string3  string4  string5  string6
		}
		System.out.println("\n------------------");
		
		//给linkedList集合添加元素
		linkedList.add("string1");
		linkedList.add("string2");
		linkedList.add("string3");
		linkedList.add("string4");
		linkedList.add("string5");
		linkedList.add("string5");
		linkedList.add(null);
		linkedList.addFirst("string0");//在集合头部添加元素
		linkedList.addLast("string6");//在集合尾部添加元素
		System.out.println(linkedList.toString());//[string0, string1, string2, string3, string4, string5, string5, null, string6]
		System.out.println(linkedList.getFirst());//string0，获取头部元素
		System.out.println(linkedList.getLast());//string6，获取尾部元素
		linkedList.removeFirst();//移除第一个元素
		linkedList.removeLast();//移除最后一个元素
		System.out.println(linkedList.toString());//[string1, string2, string3, string4, string5, string5, null]
		
	}
}

 （2）Set接口

用来包含一组无序无重复的对象

Set接口的常见实现类

  • HashSet — HashSet的特性在于其内部对象的散列存取，即采用哈希技术
  • TreeSet — TreeSet存入的顺序跟存储的顺序不同，但是存储是按照排序存储的

例子：

package test;

import java.util.HashSet;
import java.util.TreeSet;

public class Test {
	public static void main(String[] args) {
		HashSet<String> hashSet = new HashSet<>();
		hashSet.add("123");
		hashSet.add("45");
		hashSet.add("67");
		hashSet.add("89");
		System.out.println(hashSet.toString());//[45, 67, 89, 123]
		
		TreeSet<Integer> treeSet = new TreeSet<>();
		treeSet.add(123);
		treeSet.add(456);
		treeSet.add(789);
		treeSet.add(156);
		System.out.println(treeSet.toString());//[123, 156, 456, 789]
	}
}

4.Iterator接口

Iterator是为遍历而设计，能够从集合中取出元素和删除元素，但是没有添加元素的功能；使用中，只能单向移动

（1）Iterator常用方法 

（2）例子：

package test;

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

public class Test {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("123");
		list.add("456");
		list.add("789");
		list.add("156");
		list.add("178");
		Iterator<String> iterator = list.iterator();
		while(iterator.hasNext()){
			String string = iterator.next();
			System.out.print(string + "  ");//123  456  789  156  178  
			if(string.equals("156")){//移除元素“156”
				iterator.remove();
			}
		}
		System.out.println("\n" + list.toString());//[123, 456, 789, 178]
	}
}

5.迭代器模式（重点）

迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。

（1）创建自定义迭代器接口

package test;

/**
 * @author lqh 自定义迭代器
 */
public interface MyIterator<T> {
	/**
	 * 判断游标右边是否有元素
	 * @return 查询结果
	 */
	public boolean hasNext();
	
	/**
	 * 返回游标右边的元素并将游标移动到下一个位置
	 * @return 游标右边的元素
	 */
	public T next();
	
	/**
	 * 删除游标左边的元素，在执行完next之后，该操作只能执行一次
	 */
	public void remove();
}

（2）自定义集合类

package test;

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

/**
 * @author lqh 自定义集合
 */
public class MyList<T> {

	private List<T> list = new ArrayList<T>();// 集合属性造假

	/**
	 * 添加元素
	 * 
	 * @param element
	 */
	public void add(T element) {
		list.add(element);
	}

	/**
	 * 获取对应索引的元素
	 * 
	 * @param index
	 */
	public void get(int index) {
		list.get(index);
	}

	@Override
	public String toString() {
		StringBuffer result = new StringBuffer("[");
		for (T t : list) {
			result.append(t + " ");
		}
		result.append("]");
		return result.toString();
	}
	
	public MyIterator<T> iterator() {
		return new MyIteratorImpl();
	}

	/**
	 * @author lqh 实现自定义迭代器
	 */
	private class MyIteratorImpl implements MyIterator<T> {

		private int index = 0;// 游标指向的位置

		@Override
		public boolean hasNext() {
			boolean isFlag = false;
			if (list == null || list.size() == 0) {
				isFlag = false;
			} else if (index < list.size()) {
				isFlag = true;
			} else {
				isFlag = false;
			}
			return isFlag;
		}

		@Override
		public T next() {
			T element = list.get(index);
			index++;
			return element;
		}

		@Override
		public void remove() {
			index--;
			list.remove(index);
		}
	}
}

（3）测试

package test;

public class Test {
	public static void main(String[] args) {
		MyList<String> mylist = new MyList<>();
		mylist.add("123");
		mylist.add("456");
		mylist.add("789");
		mylist.add("156");
		mylist.add("178");
		MyIterator<String> iterator = mylist.iterator();
		while (iterator.hasNext()) {
			String string = iterator.next();
			System.out.print(string + "  ");// 123  456  789  156  178  
			if (string.equals("156")) {// 移除元素“156”
				iterator.remove();
			}
		}
		System.out.println("\n" + mylist.toString());// [123 456 789 178 ]
	}
}

6.Collections类

Collections类是类似于Arrays类的公用工具类 ,它提供了一些static方法供集合类使用或操作集合类 

（1）Collections常见方法

 （2）例子

package test;

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

public class Test {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("Tom");
		list.add("tom");
		list.add("atom");
		list.add("ctom");
		list.add("bcom");
		System.out.println("集合中的最大元素为：" + Collections.max(list));//集合中的最大元素为：tom
		System.out.println("集合中的最小元素为：" + Collections.min(list));//集合中的最小元素为：Tom
		Collections.sort(list);//排序
		System.out.println("排序之后集合为：" + list.toString());//[Tom, atom, bcom, ctom, tom]
		Collections.reverse(list);//逆序
		System.out.println("逆序之后集合为：" + list.toString());//逆序之后集合为：[tom, ctom, bcom, atom, Tom]
		
	}
}

7.自定义比较器（重点）

（1）第一种方式：

创建实体类不实现Comparable接口，并创建自定义比较器

①实体类

package test;

/**
 * @author lqh 书本类，不实现Comparable接口
 */
public class Book {
	private Integer book_no;//图书编号
	private String book_name;//书名
	private Double price;//价格

	public Integer getBook_no() {
		return book_no;
	}

	public void setBook_no(Integer book_no) {
		this.book_no = book_no;
	}

	public String getBook_name() {
		return book_name;
	}

	public void setBook_name(String book_name) {
		this.book_name = book_name;
	}

	public Book(Integer book_no, String book_name, Double price) {
		this.book_no = book_no;
		this.book_name = book_name;
		this.price = price;
	}

	public Book() {
	}

	@Override
	public String toString() {
		return "Book [book_no=" + book_no + ", book_name=" + book_name + ", price=" + price + "]";
	}

	public Double getPrice() {
		return price;
	}

	public void setPrice(Double price) {
		this.price = price;
	}
}

 ②自定义比较器类

package test;

import java.util.Comparator;

/**
 * @author lqh 自定义书名比较器，实现Comparator接口
 */
public class BookNameComparator implements Comparator<Book>{

	@Override
	public int compare(Book o1, Book o2) {
		return o1.getBook_name().compareTo(o2.getBook_name());//比较两个对象的书名
	}
	
}

（2）第二种方式：

创建实体类实现Comparable接口

package test;

/**
 * @author lqh 用户类，实现Comparable接口，按用户id排序
 */
public class User implements Comparable<User> {
	private Integer id;// 用户id
	private String name;// 用户姓名

	public Integer getId() {
		return id;
	}

	public User(Integer id, String name) {
		this.id = id;
		this.name = name;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + "]";
	}

	public User() {
	}

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

	public String getName() {
		return name;
	}

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

	@Override
	public int compareTo(User o) {
		return this.id.compareTo(o.id);
	}
}

（3）测试

package test;

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

public class Test {
	public static void main(String[] args) {
		List<Book> books = new ArrayList<>();
		List<User> users = new ArrayList<>();
		books.add(new Book(1001, "bcd", 120.5));
		books.add(new Book(1002, "dfb", 120.5));
		books.add(new Book(1003, "abc", 120.5));
		books.add(new Book(1004, "gd", 120.5));
		books.add(new Book(1005, "bc", 120.5));
		users.add(new User(1001, "tom1"));
		users.add(new User(1000, "tom2"));
		users.add(new User(1020, "tom3"));
		users.add(new User(1010, "tom4"));
		Collections.sort(books, new BookNameComparator());//第一个参数是Book类的集合，第二个参数是比较器对象
		System.out.println("按书名排序后：");
		for (Book book : books) {
			System.out.println(book.toString());
		}
		/*
			Book [book_no=1003, book_name=abc, price=120.5]
			Book [book_no=1005, book_name=bc, price=120.5]
			Book [book_no=1001, book_name=bcd, price=120.5]
			Book [book_no=1002, book_name=dfb, price=120.5]
			Book [book_no=1004, book_name=gd, price=120.5]
		 */
		
		Collections.sort(users);
		System.out.println("按用户id排序后：");
		for (User user : users) {
			System.out.println(user.toString());
		}
		/*
			User [id=1000, name=tom2]
			User [id=1001, name=tom1]
			User [id=1010, name=tom4]
			User [id=1020, name=tom3]
		 */
	}
}

·青红造了个白·
关注
Java基础：（七）数组
地球村
08-17 1096
创建数组 数组是相同类型数据的有序集合 1.相同类型的若干个数据,按照一定先后次序排列组合而成。 2.其中,每一个数据称作一个数组元素 3.每个数组元素可以通过一个下标来访问它们 数组特点 1.其长度是确定的。数组一旦被创建，它的大小就是不可以改变的 2.其元素必须是相同类型,不允许出现混合类型 3.数组中的元素可以是任何数据类型，包括基本类型和引用类型 数组属引用类型 length, elem...
Java第五天笔记01——面向对象基础
lqh的博客
01-07 531
1.面向过程和面向对象的编程思想 （1）面向过程解决问题的思路： 面向过程的抽象是将实现一个功能的一组命令组合成为一个函数，这个函数就能实现这一个功能，是对功能实现的一种抽象，有了函数，我们就没有必要重复写很多的代码(特殊地譬如递归，可通过循环替代)，仅仅一个代码集合名称以及参数就能调用抽象的命令集合。 （2）面向对象解决问题的思路： 从现实世界中客观存在的事物出发来构造软件系统，并在系统构造中尽可能运用人类的自然思维方式，强调直接以问题域中的事物为中心来思考问题，认识问题，并根据这些事物的本质特..
Java第九天笔记02——集合2
lqh的博客
01-15 200
目录 1.Map接口 2.集合类的选择 3.泛型的使用 1.Map接口 Map内存储的是键/值对这样以成对的对象组(可以把一组对象当成一个元素)，通过“键”对象来查询“值”对象 （1）Map接口有两个实现：HashMap — key/value对是按照Hash算法存储的TreeMap — key/value对是排序(按key排序)存储的 （2）常用方法： （3）例子 package test; import java.util.HashMap; import java.util.I
Java学习笔记十七——集合类详细总结各自对比
Pandafz的博客
10-12 4238
一、Java集合介绍
黑马程序员Java学习笔记（源代码+图片+笔记）——集合
weixin_65098078的博客
07-24 1152
黑马程序员Java学习笔记（源代码+图片+笔记）——集合
Java核心技术读书笔记——集合
安洁莉娅丶的博客
11-27 750
目录1.集合接口与实现相互分离1.1Java类库中集合接口和迭代器接口1.2泛型实用方法2.具体的集合2.1链表 1.集合接口与实现相互分离 1、Java的集合类库也将接口和实现相分离。 2、队列有两种实现方式，一种是循环数组，一种是链表 如果想要用循环数组，则使用ArrayDeque 如果想要用链表，则使用LinkedList 3、当程序一旦构建了集合时，就不需要知道究竟使用了哪种集合，因此，只有在构建集合时使用具体的类才有意义。 一个好习惯，就是用接口类型存放集合的引用。 Queue<Custom
java集合笔记二 —— List集合（概念方法，list集合去重，模拟栈结构(1)
2401_84002294的博客
04-29 527
底层数据结构是链表，查询慢，增删快线程不安全，效率高添加功能：public void addFirst(Object obj):在该集合开头插入指定的元素public void addLast(Object obj)将指定的元素追加到此列表的末尾。// 这个方法相当于add(Object)。获取功能：public Object getFirst():返回此集合中的第一个元素。getLast()：返回此列表中的最后一个元素。
Java笔记17——Java集合（上）
来自82年的博客
07-12 447
Java学习——Java集合（上） 文章目录Java学习——Java集合（上）一、对象容器——集合(1). 类集设置的目的二、三大父接口——Collection(1).List 接口1.ArrayList2.VectorVector 类和 ArrayList 类的区别3.链表操作类：LinkedList(1).Set 接口1.散列存放：HashSet2.排序的子类：TreeSet关于重复元素的说明总结 一、对象容器——集合 集合本质是基于某种数据结构数据容器。常见的数据结构：数组（Array）、集（Se
Java笔记整理 —— Collection集合
Acc222222的博客
01-04 361
Collection Collection接口由两个重要的子接口 List和Set，实现子类都是单列集合。 集合体系图 Collection常用方法（用ArrayList演示） Collection常用方法对于Collection以及下属子类都可以用。 1. add: 添加单个元素 ArrayList a = new ArrayList(); a.add(10); //注意放入的是Integer类，其余同理 a.add(true); .
java集合笔记二 —— List集合（概念方法，list集合去重，模拟栈结构）(1)
2401_84048542的博客
05-05 713
底层数据结构是链表，查询慢，增删快线程不安全，效率高添加功能：public void addFirst(Object obj):在该集合开头插入指定的元素public void addLast(Object obj)将指定的元素追加到此列表的末尾。// 这个方法相当于add(Object)。获取功能：public Object getFirst():返回此集合中的第一个元素。getLast()：返回此列表中的最后一个元素。
Java第十天笔记01——文件与流
lqh的博客
01-16 464
目录 1.File类 2.流的概念及API 3.字节输入流 4.字节输出流 5.使用字节输入和字节输出流复制文件 6.字符输入流 7. 字符输出流 8.字符输入和字符输出流复制文件内容 9.使用处理流复制文件内容 1.File类 （1）常见构造方法 ①File 变量名 = new File(String pathname); ②File 变量名 = new File(URI uri); ③File 变量名 = new File(String parent, String chi.
Java笔记11——集合
qq_53855503的博客
07-25 213
集合 特性： 1.长度不固定，动态扩容 2.通过索引来获取元素 3.可以存储各种类型存储数据 4.各式各样的容器来存储数据 目的： 就是为了提高，优化数组的使用；因为集合框架的某些类是数组封装的 Iterable：顶级接口 terable的方法： Iterable iterable();被称为迭代器，输出用的 -Collection：接口 方法： 1.add();添加一个元素 2.clear();清除集合中所有元素 3.contains(Object o);判断容器中是否包含指定对象 4.equals(O
博学谷：Java基础知识精讲学习笔记——DAY2
qq_46000312的博客
12-31 462
1. Date类 ​ 日期和日历类，用于操作日期相关信息。 ​ 构造方法 Date() : 构造一个日期对象，当前系统时间，精确到毫秒。 package cn.itcast.dateandcalendardemo; import java.util.Date; public class Test { public static void main(String[] args) { //测试Date类 //测试空参构造，采用的是当前系统的默认时间。
Java学习笔记——Set集合
yjh728的博客
07-01 261
Set集合 Set集合概述 Set集合类似于一个罐子，他只管把对象放进罐子中，而不管放入的次序 Set集合与Collection集合基本相同，没有提供任何额外的方法 Set集合不允许添加重复元素，若试图添加两个相同元素进入同一个Set集合中，则添加失败，add()方法返回false， 且新元素不会被加入 Set集合的实现类——HashSet类 HashSet是Set接口的典型实现 H...
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 550
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 418
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 702
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
最新发布
qq_57340195的博客
10-17 851
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 925
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
达内内部：JAVA面向对象编程笔记——高内聚与复用
Java的面向对象编程是现代软件开发的核心概念，它是基于达内内部课堂笔记的内容，旨在提升程序员对Java语言面向对象特性理解。在Java中，面向对象编程（OOP）是对现实世界中的实体及其行为进行抽象和模拟的一种编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值