Java编程思想笔记11——第11章：持有对象

最新推荐文章于 2022-03-20 16:20:36 发布
最新推荐文章于 2022-03-20 16:20:36 发布
阅读量128 收藏
点赞数
分类专栏： Java 文章标签： queue java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35556504/article/details/119058754
版权

11 持有对象

​ 通常，程序总是根据运行时才知道某些条件去创建新的对象。

​ 不需要事先定义好创建的数量，可以根据需要创建任意数量的对象。

​ 数组则必须实现指定数量，所以有所约束。

​ Java提供了容器类来解决这个问题，基本的类型是List、Set、Queue和Map。这些称之为集合类，且都是Collection类或Map类的子类。

​ Set不能保存重复值。 Map允许将对象与其他对象关联起来。

​ 这些容器不需要事先指定大小。

​

11.1 泛型和类型安全的容器

​ 在JavaSE5之前，可以像容器插入不正确的类型，例如创建一个Arraylist，既可以插入Apple类型，也可以插入Orange类型

​ 通过add()方法插入对象，通过get方法访问这些数据。

（1）不使用泛型

​ 因为没有使用泛型，所以会提示警告，可以使用@SuppressWarnings来抑制。

class Cat{ }
class Dog{ }

public class Test {
    @SuppressWarnings("unchecked")  //不提示警告
	public static void main(String[] args) {	
		ArrayList dogs = new ArrayList();
		dogs.add(new Cat());
		dogs.add(new Dog());	
	}
}

当不指定类型时，默认是Object类。因为所有类都继承Object

（2）使用泛型

​ 使用泛型，意味着你不可以插入其他类型的数据

class Cat{ }
class Dog{ }

public class Test {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {	
		ArrayList<Dog> dogs = new ArrayList<Dog>();
//		dogs.add(new Cat()); // 会报错，不可以插入
		dogs.add(new Dog());	
        for (Dog dog : dogs) { //使用增强for循环进行遍历
			System.out.println(dog);
		}
	}
}

（3）使用泛型，可以插入其子类

class Dog{ }
class Hasiqi extends Dog{} //哈士奇
class Keji extends Dog{} //柯基


public class Test {
	public static void main(String[] args) {	
		ArrayList<Dog> dogs = new ArrayList<Dog>();
		dogs.add(new Hasiqi());
		dogs.add(new Keji());
		
	}
}

11.2 基本概念

​ Java容器的用途是"保存对象"，并将其分为两个不同大类

​ （1）Collection。 包括List、Set、Queue等接口。

​ List表示数据是有顺序的，Set则不可以有重复元素，Queue则按照规则来确定顺序

​ （2）Map， 由一堆键值对组成，通过字典的形式将其关联起来。

List<Dog> dogs = new ArrayList<Dog>();
List<Dog> dogs = new LinkedList<Dog>();
// 这里的List是接口， 接口可以指向其子类。


import java.util.Collection;
Collection<String> c = new ArrayList<String>();
c.add("abc");

11.3 添加一组元素

​ Arrays.asList()方法接受一个数组或者用逗号分割的元素列表（可变参数），将其转换为List对象

​ Collections.addAll()方法接受一个Collection对象，或者可变参数，将其添加到Collection中

import java.util.*;

public class Test {
	public static void main(String[] args) {		
		List<Integer> list = Arrays.asList(1,2,3,4,5);	
		Integer[] ins = {5,6,7,8};
		List<Integer> list2 = Arrays.asList(ins);
		
		Collection<Integer> coll = new ArrayList<Integer>(
				Arrays.asList(1,2,3,4,5) );
		Collections.addAll(coll, 1,2,3,4,5);
		Collections.addAll(coll,ins);
	}
}

11.4 容器的打印

​ 使用Arrays.toString()来进行打印

public class Test {
	public static void main(String[] args) {		
		Collection coll = new ArrayList<Integer>();
		coll.add("zhangsan");
		coll.add("lisi");
		System.out.println(coll);
		
		Map map = new HashMap();
		map.put("name","zhangsan");
		map.put("age",18);
		System.out.println(map);
	}
}
// 输出结果
// [zhangsan, lisi]
// {name=zhangsan, age=18}

List : 以特定的顺序保存元素

Set：不能存储重复元素

Queue： 只允许一端插入，另一端移出

ArrayList和LinkedList都是List类型

HashSet、TreeSet和LinkedHashSet都是Set类型。 HashSet使用哈希表存储，查询时间快。

HashMap、TreeMap、LinkedHashMap都是Map类型。

11.5 List

​ List接口在Collection的基础上添加了大量的方法。

​ ArrayList，随机查询元素快，但是插入和删除速度慢

​ LinkedList，随机查询元素慢，但是插入和删除快。

import java.util.*;
class Dog{} 
class Hasiqi extends Dog{}

public class Test {
	public static void main(String[] args) {		
		List<Dog> dogs = Arrays.asList(new Dog(),new Dog());
		
		Dog d = new Dog();
		dogs.add(d);//添加一个dog数据
		dogs.remove(d); //删除
		Dog hashqi = new Hasiqi();
		System.out.println(dogs.indexOf(hashqi)); //查看哈士奇的下标
		
		dogs.get(1); //获取元素
		dogs.add(1,new Dog()); //给指定位置添加
		List<Dog> sub = dogs.subList(1, 2);//获得子串
		dogs.containsAll(sub); //是否都包含
	}
}

11.6 迭代器

​ 为什么要使用迭代器？如果刚开始使用的是List编码，后来发现还需要应用于Set，那么就得重头开始编码。

​ 使用迭代器（Iterable）则没有这个问题。

​ Java的Iterable只能单向移动。使用iterator()来获得迭代器对象，使用next()获得下一个元素，使用hashNext()检查是否还有下一个，使用remove()来删除元素。

public class Test {
	public static void main(String[] args) {	
		
		List<Integer> list = new ArrayList<Integer>(
				Arrays.asList(1,2,3,4,5,6,7,8));
		Iterator<Integer> it = list.iterator();
		while(it.hasNext()) {
			Integer temp = it.next();
			System.out.println(temp);
		}	
	
	}
}

11.6.1 ListIterator

​ ListIterator是一个更加强大的Iterator的子类。

​ Iterator只能向前移动，但是ListIterator可以双向移动。

​ 可以通过listIterator(n)来指定起始位置

public class Test {
	public static void main(String[] args) {	
		
		List<Integer> list = new ArrayList<Integer>(
				Arrays.asList(1,2,3,4,5,6,7,8));
		ListIterator<Integer> it = list.listIterator();
		while(it.hasNext()) {
			Integer t1 = it.next();
			System.out.println(t1);
		}
		
		while(it.hasPrevious()) {
			Integer t2 = it.previous();
			System.out.println(t2);
		}
	}
}

11.7 LinkedList

​ LinkedList 在查询方面速度慢，但是插入和删除速度较快

​ LinkedList还添加了栈，队列，双端队列的方法

​

​ getFirst() 和 element()完全一样，返回第一个元素，若为空则抛出异常

​ peek() 返回第一个元素，为空则返回null

​

​ removeFirst() 和 remove() 完全一样，删除第一个元素，为空抛出异常

​ poll() 删除第一个元素，为空则返回null

​

​ addFirst() 与 add() 和 addList() ,将某个元素插入列表尾部

​ removeLast() 删除并返回最后一个元素

​

11.8 Stack

​ 栈，先进后出。 FILO

​ push() 入栈

​ pop() 出栈

​ peek() 返回栈顶元素

​ empty() 是否为空

11.9 Set

​ 保存不重复的元素

​ Set具有与Collection完全一样的接口，没有额外的功能。

public class Test {
	public static void main(String[] args) {	
		
		Set<String> set1 = new HashSet<String>();
		Collections.addAll(set1,"2","3");
		set1.add("4");
		System.out.println(set1);
	}
}

11.10 Map

​ 计算数字出现的次数

import java.util.*;
public class Test {
	public static void main(String[] args) {		
		Random rand = new Random(5);	
		Map<Integer,Integer> map = new HashMap<Integer, Integer>();
			
		for(int i=0;i<1000;i++) {
			int t = rand.nextInt(66);//生成0-66的随机数
			
			Integer f = map.get(t);
			if (f == null) {
				f = 0;
			}else {
				f += 1;
			}
			map.put(t,f);			
		}
		
		System.out.println(map);
	}
}

11.11 Queue

​ 队列是一个先进先出（FIFO）的容器，从一段放入事物，从另一端取出。

​ LinkedList提供支持队列的行为，且实现了Queuue接口。

Queue<Integer> queue = new LinkedList<Integer>();

​ offer() 方法插入列表尾

​ poll() 和 remove() 方法 删除列表头

​ peek() 和 element() 方法 返回队头

11.11.1 PriorityQueue

​ 优先级队列，优先弹出最需要的元素。

​ 使用offer()方法插入一个对象时，会在队列中被排序。

​ 可以通过自己的Comparator来修改这个顺序。

import java.util.*;
public class Test {
	public static void main(String[] args) {	
		PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
		for(int i =10;i>0;i--) {
			pq.offer(i);
		}
		
		while(pq.peek() != null) {	
			Integer temp = pq.remove();
			System.out.println(temp);	
		}
		
	}
}
// 输出结果
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

11.12 Collection和Iterator

​ Collection时描述所有序列容器共性的根接口。

​ java.util.AbstractCollection 提供了Collection的默认实现（抽象类中的非抽象方法），可以创建AbstractCollection的子类型。

import java.util.*;
class Seq extends AbstractCollection<Integer>{

	private Integer[] int_list = {1,2,3,4,5};
	
	@Override
	public Iterator<Integer> iterator() {
		return new Iterator<Integer>() { //匿名内部类， 实现 Interator<Integer> 
			private int index = 0;
			@Override
			public Integer next() { //下一个数据
				return int_list[index++];
			}
			
			@Override
			public boolean hasNext() { // 判断是否有下一个数据
				return index < int_list.length;
			}
		};
	}

	@Override
	public int size() {
		return int_list.length;
	}
	
}


public class Test {
	public static void main(String[] args) {	
		Collection seq = new Seq();
		Iterator<Integer> it = seq.iterator();
		while(it.hasNext()) {
			Integer temp = it.next();
			System.out.println(temp);
		}
	}
}

11.13 Foreach与迭代器

​ （1）Foreach可以适用于任何Collection对象

import java.util.*;
public class Test {
	public static void main(String[] args) {	
		Collection<String> cs = new ArrayList<String>();
		Collections.addAll(cs, "long time no see".split(" "));//添加数据
		for (String str : cs) {//增强for循环
			System.out.println(str);
		}
		
	}
}

（2）继承Iterable之后，就可以使用Foreach增强for循环

import java.util.*;
class Hello implements Iterable<String>{
	private String[] str_list = {"a","b","c"};
	
	public Iterator<String> iterator(){
		return new Iterator<String>() {
			private int index =0;
			
			@Override
			public boolean hasNext() {
				return index < str_list.length;
			}

			@Override
			public String next() {
				return str_list[index++];
			}	
		};
		
	}
}

public class Test {
	public static void main(String[] args) {			
		for (String str : new Hello()) {
			System.out.println(str);
		}
		
	}
}

（3）循环map数据

public class Test {
	public static void main(String[] args) {			
		Map<String, String> map = new HashMap<String, String>();
		map.put("name", "zhangsan");
		map.put("age","18");
		
		for (Entry entry : map.entrySet()) {// entry是一个键值对， 对所有的键值对进行遍历
			System.out.println(entry.getKey()+":"+entry.getValue());
		}
		
	}
}

11.13.1 适配器方法惯用法

​ 如果想在Iterator的基础上，添加一个向后的方法，则可以使用适配器方法。

​ 适配器设计模式，通过继承，在原有的基础上添加一个向前迭代的foreach循环。

import java.util.*;
class NewArray<T> extends ArrayList<T>{
	
	public NewArray(Collection<T> c){//构造方法
		super(c);
	}
	public Iterable<T> reversed(){
		return new Iterable<T>() { //返回实现Iterable的匿名内部类
			@Override
			public Iterator<T> iterator() { //实现iterator方法
				return new Iterator<T>() { //返回匿名内部类
					int index = size()-1;

					@Override
					public boolean hasNext() {
						return index>-1;
					}
					
					@Override
					public T next() {
						// TODO Auto-generated method stub
						return get(index--);
					}
					
				};
			} // public Iterator<T> iterator()
			
		};	// return new Iterable<T>()
	}//Iterable<T> reversed()
}

public class Test {
	public static void main(String[] args) {			
		Collection<String> cs = new ArrayList<String>();
		Collections.addAll(cs, "a b c d e".split(" "));
		
		NewArray<String> n_list = new NewArray(cs);
		
		for (String str : n_list) {
			System.out.println(str);
		}
		for (String str : n_list.reversed()) {
			System.out.println(str);
		}
		
	}
}

11.14 总结

​ （1）数组的容量是事先确定的，但是容器则不需要事先确定

​ （2）Collection保存单一元素，Map保存键值对。

​ （3）数组和List都是排好序的容器，List能够自动扩充容量

​ （4）随机访问，使用ArrayList， 经常在表中间插入和删除，则使用LinkedList

​ （5）LinkedList提供实现Queue和栈的行为

​ （6）HashMap快速访问数据，TreeMap保持key的排序状态，LinkedHashMap保持元素插入的顺序

​ （7）Set不允许元素重复， HashSet查询速度快，TreeSet保持排序状态，LinkedHashSet保持插入的顺序

​ （8）不使用过时的Vector，Hashtable和Stack

​

其关系为

  1. Collection（接口）
    1. List（接口）
      1. LinkedList
      2. ArrayList
    2. Set（接口）
      1. LinkedList
      2. HashSet
        1. LinkedHashSet
      3. TreeSet
    3. Queue（接口）
      1. LinkedList
      2. PriorityQueue
  2. Map（接口）
    1. HashMap
      1. LinkedHashMap
    2. TreeMap

Collection可以生成Iterator

List可以生成ListIterator

半臻（火白）
关注
专栏目录
Java编程思想第四版读书笔记——第十六章 数组
severusyue的博客
08-27 910
第十六章 数组 1、数组为什么特殊 数组的效率高（唯一优点），它是一个简单的线性序列。 数组之所以优于泛型之前的容器，就是因为可以创建一个树去持有某种基本类型，意味着可以通过编译期检查，防止插入错误类型和抽取不当类型。 2、数组是第一级对象 对象数组保存的是引用，基本类型数组保存的是值。 数组的初始化： 基本类型：数值型初始化为0，char型初始化为 (char)O，bo
java编程思想学习笔记——21多线程
Burnup_110的博客
04-01 496
一、并发简介 实现并发最直接的方式是在操作系统级别使用进程。进程是运行在它自己的地址空间内的自包含的程序。多任务操作系统可以通过周期性地将CPU 从一个进程切换到另一个进程，来实现同时运行多个进程（程序）。对于进程来说，他们之间没有任何彼此通信的需要，因为他们都是完全独立的。 但是如果将进程当做并发的唯一选择，那么进程来做并发来说的话，也有他的局限性，因为进程通常来说是有数量和开销的限制的，以避免他们在不同的并发系统之间的可应用性 java采用在顺序型语言的基础上提供对线程的支持，即线程机制是在由执行程序表
Java编程思想 第十一章 持有对象
name_sakura的博客
02-28 987
文章目录标题 标题
【Java】持有对象
天才小熊猫的博客
08-07 243
如果一个程序只包含固定数量的且生命周期都是已知的对象，那么这是一个非常简单的程序。 通常，程序总是根据运行时才知道的某些条件去创建对象。在此之前，不会知道所需对象的数量，甚至不知道确切的类型。为解决这个普遍的编程问题，需要在任意时刻和任意位置创建任意数量的对象。所以，就不能依靠创建命名的引用来持有每一个对象： Mytype aReference; 一、泛型和类型安全的容器 当你制定了某个类...
java持有对象
chengshuyuan_uestc的专栏
11-13 851
java提供了大量持有对象的方式： （1）数组保存单一的
持有对象
crazy的博客
08-19 301
### Java 有多种方式保存对象（应该说是对象的引用）。         ### Java  类库中提供了一套相当完整的容器：其中基本的            类型是 List 、 Set 、 Queue 和 Map 。这些对象的类型            也称为集合类。 》》泛型和类型安全的容器        ###   ArrayList --&gt;当作“可以自动扩充自身尺寸的...
java持有对象_java基础之持有对象
weixin_42151599的博客
02-19 226
持有对象指的是Java中保存对象的方式，这次我们主要谈论是Java中的容器类。Java内的容器类可以划分为两种：①Collection。一个独立的元素序列，这些元素都服从一条或多条规则。常用的有List,Set,Queue,Stack等等。②Map。一组成对的“键值对”对象，允许我们使用键来查找值。Collection 接口概括了序列概念，关于List，Set等这些类的基本方法，在平时开发中经常用...
Java编程思想笔记(全)
最新发布
06-14
第十一章关注于如何持有对象以及对象之间的引用关系。本章探讨了对象引用的各种方式，包括强引用、软引用、弱引用和虚引用，并讨论了它们各自的用途。此外，还会介绍垃圾回收机制如何处理这些不同类型的引用，以及...
Java编程笔记13：泛型
梦幻天空
03-07 611
Java编程笔记13：泛型 图源：PHP中文网 容器中的泛型 泛型存在的理由之一是解决容器可以持有不同类型的数据的问题。 假设有一个最简单的容器： package ch13.container; import util.Fmt; class SimpleContainer { private Object content; public SimpleContainer(Object content) { this.content = content; }
Java编程笔记16：深入容器
梦幻天空
03-20 653
Java编程笔记16：深入容器 图源：PHP中文网 填充容器 填充容器会有Java编程笔记15：数组 - 魔芋红茶’s blog (icexmoon.cn)种提到的填充数组同样的问题。 和数组类似，标准库提供一个方法Collections.fill用于向容器中填充元素： package ch16.fill; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Main
第十一章：持有对象
miaoch的博客
07-17 553
持有对象，容器的用法。
java编程思想读书笔记 第十一章 持有对象（总结）
abc709272013的博客
10-08 520
1.Collection和Iterator Collection是描述所有序列容器的共性的根接口，它可能会本认为是一个“附属接口”，即因为要表示其他若干个接口的共性而出现的接口。另外，java.util.AbstractCollection类提供了Collection的默认实现，使得你可以创建一个AbstractCollection的子类时，而其没有不必要的代码重复。 使用接口描述的一个理由是它
Java学习笔记——持有对象
vinnyaptx4869的专栏
09-02 676
本文为Java编程思想第四版的学习笔记，在此感谢作者Bruce Eckel给我们带来这样一本经典著作，也感谢该书的翻译及出版人员。本文为原创笔记，转载请注明出处，谢谢。 如果一个程序只包含固定数量的且其生命周期都是已知的对象，那么这时一个非常简单的程序。通常，程序总是根据运行时才知道的某些条件去创建新对象。在此之前，不会知道所需对象的数量，甚至不知道确切的类型。为解决这个普遍的编程问题，
Java 持有对象
u014093339的博客
06-26 584
Java 持有对象    Java 提供了大量只有对象的方式,其实只有四种容器：Map,List，Set和Queue。 1）数组将数字与对象联系起来。它保存类型明确的对象，查询对象时，不需要对结果做类型转换，它可以是多维的，可以保存基本类型数据。但是，数组一旦生成，气容量就不能改变。 2）Collection保存单一元素，而Map保存相关的键值对。有了Java泛型，你就可以指定容器中存放的对
Java持有对象
IXingFu的博客
08-25 79
1.List：List接口在Collection基础上添加了大量的方法，使得可以在List的中间插入和移除元素。两种类型的List：①ArrayList：随机访问快，插入删除慢。②LinkedList：插入修改方便，随机访问慢。 contains()：用来判断某个元素是否在数组中，返回true或false。 public static void main(String args[]) { List<String> list = new ArrayList<>(); .
java持有对象_Java 持有对象
weixin_35687571的博客
02-19 69
如果一个程序中只包含固定数量的且其生命周期都是已知的对象,那么这是一个简单的程序通常程序总是根据运行时才知道的某些条件去创建对象,为解决这个普遍的编程问题,需要在任意时刻,任意位置创建任意数量的对象java有多种方式保存对象,如数组,数组比较时候保存基本数据类型,但数组的尺寸固定,显得过于受限Java 实用类库还提供了一套相当完整的容器来保存对象,其中基本的类型时Set,Queue和Map,这些对...
达内内部：JAVA面向对象编程笔记——高内聚与复用
Java的面向对象编程是现代软件开发的核心概念，它是基于达内内部课堂笔记的内容，旨在提升程序员对Java语言面向对象特性理解。在Java中，面向对象编程（OOP）是对现实世界中的实体及其行为进行抽象和模拟的一种编程...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值