集合概念与框架结构 /List集合及其实现类 /迭代器(Iterator)的使用 /Set集合

最新推荐文章于 2021-02-24 02:40:06 发布
最新推荐文章于 2021-02-24 02:40:06 发布
阅读量246 收藏
点赞数
分类专栏： Java基础篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41213748/article/details/78960116
版权

学习目标：

一：集合概念与框架结构
二：List集合及其实现类
三：迭代器(Iterator)的使用
四：Set集合

一：集合概念与框架结构（接口）

存储一个班学员信息，假定一个班容纳20名学员
1.使用数组
特点：长度固定，遍历速度快          可以存储基本类型和引用类型
如果这个班级人数增加了怎么办？

2.集合的概念

集合：Java API所提供的一系列类的实例，可以用于动态存放多个对象。
Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中
特点：长度不固定，只能存储引用类型对象                                               


 2.Collection接口

常用方法：

方法

说明

int size();　

返回此collection中的元素数

boolean isEmpty();

判断此collection中是否包含元素。

boolean contains(Object obj);

判断此collection是否包含指定的元素。

boolean add(Object element);　

向此collection中添加元素。

boolean remove(Object element); 

从此collection中移除指定的元素。

void clear();　

移除些collection中所有的元素。

Iterator iterator();　

返回在此collection的元素上进行迭代的迭代器

Object[] toArray();

把此collection转成数组。


存储特点：

Collection接口－定义了存取对象的方法。两个常用的子接口：
List接口：存放的元素有序且允许有重复的集合接口。
Set接口：存放的元素不包含重复元素的集合接口。

二： List集合及其实现类

1.List接口是Collection接口的子接口
实现List接口的集合类中的元素是有序的，且允许重复。
List集合中的元素都对应一个整数型的序号记载其在集合中的位置，可以根据序号存取集合中的元素。
JDK API所提供的List集合类常用的有
ArrayList
LinkedList
2.List接口常用方法
List接口比Collection接口中新增的几个实用方法：
public Object get(int index);
返回列表中的元素数
public Object add(int index, Object element);
在列表的指定位置插入指定元素.将当前处于该位置的元素（如果有的话）和所有后续元素向右移动
public Object set(int index, Object element) ;
用指定元素替换列表中指定位置的元素
public Object remove(int index);
移除列表中指定位置的元素
public ListIterator listIterator()
返回此列表元素的列表迭代器

2.1实现类——ArrayList

ArrayList是使用数组结构实现的List集合。


优点：
对于使用索引取出元素有较好的效率
它使用索引来快速定位对象


缺点：
元素做删除或插入速度较慢
因为使用了数组，需要移动后面的元素以调整索引顺序。

package list;

import java.util.*;

public class ArrayListDemo {

	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<String>();  
        list.add("apple");
        list.add("banana");
        list.add("orange");
        list.add("apple");  // List可以添加重复元素
        list.add("apple");  // List可以添加重复元素
        for(int i=0;i<list.size();i++){
        	System.out.print(list.get(i)+"  ");   // get(int index)方法是List接口扩展的方法
        }
        System.out.println();
        System.out.println("**********增强for循环遍历**********");
        for(String str:list){
        	System.out.print(str+"  ");
        }
        System.out.println();
        
        System.out.println("包含apple吗？"+list.contains("apple"));
        System.out.println("删除之前的元素个数："+list.size());
        list.remove("apple");
        System.out.println("删除之后的元素个数："+list.size());
        for(int i=0;i<list.size();i++){
        	System.out.print(list.get(i)+"  ");   // get(int index)方法是List接口扩展的方法
        }
	}

}
运行结果： 

apple  banana  orange  apple  apple  
**********增强for循环遍历**********
apple  banana  orange  apple  apple  
包含apple吗？true
删除之前的元素个数：5
删除之后的元素个数：4
banana  orange  apple  apple

2.2实现类——LinkedList
LinkedList是使用双向链表实现的集合。


LinkedList新增了一些插入、删除的方法。


优点：
对频繁的 插入或删除元素有较好的效率
缺点：
    查询元素时，效率低，因为要从第一个元素查找。

eg:

package list;

import java.util.LinkedList;

public class LinkedListDemo {

	public static void main(String[] args) {
		System.out.println("模拟栈数据结构(先进后出FILO)：");
		LinkedList<String> list=new LinkedList<String>();
		list.push("A");
		list.push("B");
		list.push("C");              //.push方法和.pop方法的区别
		System.out.println(list.pop());
		System.out.println(list.pop());
		System.out.println(list.pop());
		System.out.println("模拟队列数据结构(先进先出FIFO)：");
		list.add("A");
		list.add("B");
		list.add("C");
		System.out.println(list.removeFirst());
		System.out.println(list.removeFirst());
		System.out.println(list.removeFirst());
	}

}
运行结果： 
模拟栈数据结构(先进后出FILO)：
C
B
A
模拟队列数据结构(先进先出FIFO)：
A
B
C
分析总结：

ArrayList
遍历元素和随机访问元素的效率比较高，插入、删除等操作频繁时性能低下
LinkedList
插入、删除元素时效率较高，查找、遍历效率较低

三：迭代器的使用

（1）Iterator是专门的迭代输出接口。所谓的迭代输出就是将元素进行判断，判断是否有内容，如果有内容则把内容取出。


（2）Iterator对象称作迭代器，用以方便的实现对集合内元素的遍历操作。

1.所有实现了Collection接口的集合类都有一个iterator()方法用以返回一个实现了Iterator接口的对象。
Iterator it = coll.iterator();
while(it.hasNext()){
      it.next();
}

2.Iterator接口中定义了如下方法：
boolean hasNext(); //判断游标右边是否有元素
Object next(); //返回游标右边的元素并将游标移动到下一个位置

eg:

package iterator;
import java.util.*;
public class IteratorDemo {

	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<>();
		Collections.addAll(list,"China","America","Japan","China","France");
		Iterator<String> iter=list.iterator();   // 返回List集合的迭代器
		// 通过迭代器遍历集合
		while(iter.hasNext()){
			System.out.print(iter.next()+"  ");
		}

	}

}


3.另一种遍历集合的方法：
用增强for遍历集合中的元素
凡是能用 Iterator 迭代的集合都可以用JDK5.0中增强的for循环来更简便的遍历。
  List<String> list=new ArrayList<String>();
  …
eg: for(String data:list){
             System.out.print(data+”  ”)
      }

（4）泛型

泛型（Generic  type）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。
泛型的好处：解决了类型安全的问题(运行期出现“java.lang.ClassCastException”异常)

 受限泛型
         a. 设置上限

            类名称<? extends 上限类>                  //只能接收上限类对象或其子类对象

         b.设置下限

            类名称<?  super  下限类>                     //接收下限类对象或其父类对象

eg: 

package generic;

import java.util.*;

public class GenericDemo {

	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<String>();
        list.add("LX");
        list.add("XJ");
        for(String data:list){
        	System.out.print(data+"  ");
        }
        
        method(list);
        method(new ArrayList<Object>());
	}
	
	public static void method(List<? super String> list){
		List<String> temp=(List<String>)list;
		temp.add("ZH");
	}
	
	

}

四：Set接口的实现类

Set接口没有提供Collection接口额外的方法，但实现Set接口的集合类中的元素是不可重复的。




JDK API中所提供的Set集合类常用的有：
HashSet：散列存放
TreeSet：有序存放（自动去重）
LinkedHashSet

HashSet存储原理

根据每个对象的哈希码值(调用hashCode()获得)用固定的算法算出它的存储索引，把对象存放在一个叫散列表的相应位置(表元)中：
如果对应的位置没有其它元素，就只需要直接存入。
如果该位置有元素了，会将新对象跟该位置的所有对象进行比较(调用equals())，以查看是否已经存在了：还不存在就存放，已经存在就不存储。
HashSet不保存元素的加入顺序。
HashSet接口存、取、删对象都有很高的效率。
对于要存放到HashSet集合中的对象，对应的类可以重写hashCode(Object obj)方法和equals()以实现对象相等规则的编写。

eg1:


Person类

eg2:

package set.hashset;

import java.util.HashSet;

public class HashSetDemo {

	public static void main(String[] args) {
		HashSet<String> set=new HashSet<String>();
		set.add("apple");
		set.add("banana");
		set.add("orange");
		set.add("apple");
		set.add("apple");
		for(String str:set){
			System.out.print(str+"  ");
		}

	}

}



package set.hashset;

public class Person {
    private String name;
    private int age;
    public Person(){
    }
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	
	@Override
	public int hashCode() {
		return this.age*2;
	}
	
	@Override
	public boolean equals(Object obj) {   //定义方法去重
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(!(obj instanceof Person)){
			return false;
		}
		Person per=(Person)obj;
		if(this.name!=null && this.name.equals(per.name) && this.age==per.age){
			return true;
		}
		return false;
	}
	
	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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}
Text类： 

package set.hashset;

import java.util.HashSet;

public class PersonHashSet {

	public static void main(String[] args) {
		HashSet<Person> set=new HashSet<Person>();
		set.add(new Person("XX",20));
		set.add(new Person("YY",22));
		set.add(new Person("zz",21));
		set.add(new Person("CC",20));
		set.add(new Person("BB",20));
		
		for(Person per:set){
			System.out.println(per);
		}

	}

}
Treeset集合的特点：
TreeSet:可以对加入其中的元素进行排序。但前    提是，必须指定排序规则。


构造方法： public TreeSet()
    如果使用TreeSet的无参构造实例化TreeSet集合，则加入到TreeSet集合中的元素所对应的类必须实现java.lang. Comparable<T>接口，复写其中的int compareTo(T o)方法，并在方法中编写排序规则。
在Comparable<T>接口的compareTo(T o)方法中，指定排序规则(以升序为例)：
 public int compareTo(Girl girl)｛
         if(this.xxx>girl.xxx){
                   return 1;
         }else if(this.xxx<girl.xxx){
                   return  -1;
        }else{
                   return 0;
        }
｝
TreeSet比较排序的过程，已经对重复元素去重了。

eg1:

package set.treeset;

import java.util.TreeSet;

public class TreeSetDemo {

	public static void main(String[] args) {
		TreeSet<String> set=new TreeSet<String>();
		set.add("X");
		set.add("A");
		set.add("Y");
		set.add("B");
		set.add("A");
		set.add("Y");
		for(String str:set){
			System.out.print(str+"  ");
		}

	}

}
结果:

A  B  X  Y  (自动去重)
eg2:

//Girl类

package set.treeset;

public class Girl implements Comparable<Girl>{
	private String name;   // 姓名
	private int face;    // 颜值
	private double money;  // 经济

	public Girl() {

	}

	public Girl(String name, int face, double money) {
		super();
		this.name = name;
		this.face = face;
		this.money = money;
	}
	
	
	// 在该方法中指定排序规则
	@Override
	public int compareTo(Girl girl) {
		System.out.println("*****************************");
		if(girl==null){
			return 1;
		}
		if(this.face>girl.face){
			return -1;
		}else if(this.face<girl.face){
			return 1;
		}else{
			if(this.money>girl.money){
				return -1;
			}else if(this.money<girl.money){
				return 1;
			}else{
				return this.name.compareTo(girl.name);
			}
		}
		
	}

	@Override
	public String toString() {
		return "Girl [name=" + name + ", face=" + face + ", money=" + money
				+ "]";
	}

	

}
Text类： 
package set.treeset;

import java.util.TreeSet;

public class PersonTreeSet {

	public static void main(String[] args) {
		TreeSet<Girl> set=new TreeSet<Girl>();
        set.add(new Girl("小红",75,20.5));
        set.add(new Girl("LX",60,80.9));
        set.add(new Girl("XJ",90,2.5));
        set.add(new Girl("JJ",85,30.5));
        set.add(new Girl("MyN",86,30.5));
        for(Girl girl:set){
        	System.out.println(girl);
        }
        
	}

}


Super戏子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合（List、Set）遍历和Iterator迭代器
程序员世杰
01-14 1885
一、Iterator迭代器 1.介绍 迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为 “轻量级” 对象，因为创建它的代价小。 Iterator，所有的集合类，都实现了 Iterator 接口（因为Collection 接口继承Iterator接口），这是一个用于遍历集合中元素的接口，并且只能单向移动。主要包含以下三种方法： ...
JAVA Iterator 转成 List
热门推荐
博主是个懒蛋
03-14 5万+
List转到Iterator容易，JDK本身就支持，反过来的实现方式如下： 1.使用Apache Common Collections  2.自己实现的方法转换 3.Guaa实现转换 方式1： #Apache Commons Collections: import org.apache.commons.collections.IteratorUtils; Iterator myIt
迭代器实现List 、Set、Map
bll1992的博客
07-18 153
package cn.henu.Mycollection; import java.util.*; /** * 迭代器也就是将集合的数据放到一个容器中并成一排，iterator有一个游标， * 最初的时候，游标在第一个元素前面，调用Iterator.next()是将游标往后移一位， * Iterator是判断游标后面还有没有可以迭代的元素。 */ public class TestI...
迭代器的应用和集合进阶List&Set
coder_bai的博客
08-04 481
集合进阶List&Set，迭代器的应用和增强for循环foreach
Java使用Iterator迭代器遍历集合数据的方法小结
08-25
Java使用Iterator迭代器遍历集合数据的方法小结 Java语言中，使用Iterator迭代器遍历集合数据是一种常见的操作。本文主要介绍了Java使用Iterator迭代器遍历集合数据的方法，并结合实例形式分析了Java迭代器进行集合...
Iterator迭代器的简单介绍与使用
12-21
Iterator迭代器是Java集合框架的重要组成部分，主要用于遍历Collection接口的子类，如List、Set等集合中的元素。不同于Collection和Map接口，Iterator接口不直接存储元素，而是提供了一种顺序访问集合元素的方式，...
Java中Set&List的迭代器实现步骤解析
08-25
Java中Set&List的迭代器实现步骤解析 Java中Set和List的迭代器实现步骤解析是Java编程语言中一...Java中Set和List的迭代器实现步骤解析是一个重要的知识点，它可以帮助开发者更好地理解Java集合框架，并提高编程效率。
Java集合Set、List、Map的遍历方法
09-04
2. 使用`Iterator`遍历：与Set相同，使用迭代器访问元素。 ```java Iterator<String> it = list.iterator(); while (it.hasNext()) { System.out.println(it.next()); } ``` 3. 增强for循环：同样适用于List，按照...
Java集合类的组织结构和继承、实现关系详解
08-28
Java集合类的组织结构和继承、实现关系是理解和使用Java集合类的关键。 Iterable接口是Java集合类的根接口，所有集合类都实现了这个接口。Iterable接口定义了一个 iterator() 方法，用于返回一个迭代器对象，迭代器...
Iterator to list的三种方法
01-20
文章目录简介使用while使用ForEachRemaining使用stream总结 Iterator to list的三种方法 简介 集合的变量少不了使用Iterator，从集合Iterator非常简单，直接调用Iterator方法就可以了。 那么如何从Iterator反过来生成List呢？今天教大家三个方法。 使用while 最简单最基本的逻辑就是使用while来遍历这个Iterator，在遍历的过程中将Iterator中的元素添加到新建的List中去。 如下面的代码所示： @Test public void useWhile(){ List stringLi
set,list集合以及迭代器
weixin_44136661的博客
09-10 220
set和for,iterator @Test public void setTest01(){ //set 特点1：里面的元素不可以重复 A B C C 特点2：无序 //<> 泛型，用来指定元素的类型，只要指定，其他类型的元素不能存入 Set<String> sets =new HashSet<>(); sets.add("a"); sets.add("b");
Java集合遍历的几种方式总结及比较
whyherry的博客
11-05 1142
学习Java的同学注意了！！！  学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：279558494 我们一起学Java！ 集合类的通用遍历方式, 用迭代器迭代: Iterator it = list.iterator(); while(it.hasNext()) { Object obj = it.next(); } Map遍历方式：
java iterator 转 list_JAVA Iterator 转成 List
weixin_29406875的博客
02-13 800
List转到Iterator容易，JDK本身就支持，反过来的实现方式如下：1.使用Apache Common Collections2.自己实现的方法转换3.Guaa实现转换方式1：#Apache Commons Collections:import org.apache.commons.collections.IteratorUtils;Iterator myIterator = //some ...
【迭代器】自己写一个集合实现Iterable迭代功能
闲着没事_玩玩JAVA的专栏
10-28 694
import java.util.Iterator; public class Test { public static void main(String[] args) { MyCollection myCollection=new MyCollection(); for(int i=0;i<100;i++) System.out.println("add---
Iterator 接口的使用 所有的Collection接口类都有一个iterator方法
kokodudu的专栏
11-10 1775
/* * Iterator 接口的使用 所有的Collection接口类都有一个iterator方法  *以返回一个实现了Iterator接口的对象 */ import java.util.*; class Name { private String firstname; private String lastname; Name(String firstna
集合中迭代器的原理及源码解析
汐小旅Shiory
05-05 383
迭代器原理： 迭代器是对集合进行遍历，而每一个集合内部的存储结构都是不同的，所以每一个集合存和取都是不一样，那么就需要在每一个类中定义hasNext()和next()方法，这样做是可以的，但是会让整个集合体系过于臃肿。迭代器是将这样的方法向上抽取出接口，然后在每个类的内部，定义自己迭代方式。 这样做的好处有二：第一，规定了整个集合体系的遍历方式都是hasNext()和next()方法；第二，代...
java iterator转list_关于java：将Iterator转换为ArrayList
weixin_36212175的博客
02-24 1634
给定Iterator，我们如何以最佳和最快的方式将Iterator转换为ArrayList(或List)，以便我们可以对其使用ArrayList的操作，例如get(index)， add(element)等更好地使用像Guava这样的库：import com.google.common.collect.Lists;Iterator myIterator = ... //some iteratorL...
Java集合框架详解：List, Set, Map与迭代器
- `Iterator`：用于遍历集合的迭代器接口，`ListIterator`扩展了Iterator，提供了更丰富的遍历功能，如双向操作。 - `SortedSet`和`SortedMap`：与Set和Map类似，但元素按顺序排列，`TreeSet`和`TreeMap`分别实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值