Java教程

【Java】集合与数组关系,认识集合,使用集合,集合使用判断情况

本文主要是介绍【Java】集合与数组关系,认识集合,使用集合,集合使用判断情况,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

目标①:了解集合和数组的区别

在Java中,集合位于java.util包下。

从定义看区别:

集合定义:集合是一个不定量存放对象的引用的容器。

数组定义:数组是一个定量存放“相同类型”变量的容器。

那么从定义的角度上看,数组和集合的区别:

  • 数组和集合都是Java中的容器

  • 数组的长度是固定的,集合的长度是可变的(数组是静态的,一个数组实例具有固定的大小,一旦创建了就无法改变容量了。而集合是可以动态扩展容量,可以根据需要动态改变大小,集合提供更多的成员方法,能满足更多的需求)

  • 数组只能存储相同数据类型的数据,这里的数据类型可以是基本数据类型,也可以是引用类型

  • 集合可以存储不同数据类型的对象的引用(但一般情况下,我们会使用泛型来约定只使用1种数据类型),但不能存储基本数据类型

从存储结构看联系

集合存储:(集合以接口和类的形式存在,不同的实现有着不同的存储结构)看下图

image

注:粉色代表接口,绿色代表实现类;
数组、哈希表:顺序存储
哈希表、红黑树:链式存储

数组存储:链式存储

那么,

  • 数组是java语言中内置的数据类型,是线性排列的,执行效率或者类型检查都是最快的。

  • 集合以接口和类的形式存在,具有封装,继承和多态等类的特性,通过简单的方法和属性调用即可实现各种复杂的操作,大大提高软件的开发效率。

目标②:认识集合(自上而下)

Map和Collection 接口

image

左右两个集合:Collection、Map 都是接口(不能构建实例对象) 各自都有自己的实现类,以迭代器Iterator将其联系起来
经常使用的方法:
image
image
构建方法:
Collection/Map 对象 = new 实现类;

注意:Map 没有继承 Collection 接口, Map 提供 key 到 value 的映射,你可以通过“key”查找“value”。一个 Map 中不能包含相同的 key ,每个 key 只能映射一个 value

ps:Map集合必须保证保证key唯一,作为key,必须重写hashCode方法和equals方法,以保证key唯一。

List和Set 接口以及它的实现类

image

注:绿色为实现类(内包含Collection的基本方法)。据结构为数组的特点:查询快、增删慢。结构为数组链表特点:查询慢、增删快。

List 接口:
它利用索引(index),定义了一些特殊方法:
get(int index,E e) 获取指定位置的元素;remove(int index)移除指定位置的元素;
add(int index,E e) 将元素添加到指定位置;set(int index,E e) 用元素替换指定位置的元素;
Set接口:
特点:元素不可重复;
元素无序,存储及取出时顺序不一致;
没有索引,因此不能使用普通For循环遍历;
Set与Collection 接口中的方法基本一致,没有进行功能上的扩充;

Map接口以及实现方法

image

特点:元素包含两个值(key,value)即键值对, key不允许重复,value可以重复, key与value是一一对应的。元素无序;
Map接口是双列集合的最顶层接口,定义了一些通用的方法。
put(key , value) 添加元素; remove(key) 删除key对应元素;
containsKey(key) 判断是否存在key对应元素;get(key) 获取key对应元素;
KeySet() 获取所有的key,存到Set集合中;entrySet() 获取所有的元素,存到Set集合中;
ps:Map集合必须保证保证key唯一,作为key,必须重写hashCode方法和equals方法,以保证key唯一。

使用集合进行操作(此内容来自csdn:java集合基础习题代码部分改动)

一.生成10个1到20之间的不重复的随机数

分析过程:

  1. 需要生成随机数,那么需要Random类

  2. 需要存储10个不能重复的数,需要HashSet集合(当前TreeSet还没学习到)

  3. 判断,当HashSet的Size小于10就往里存储随机数,等于就停止添加存储元素

  4. 通过Random的nextInt()方法获取随机数并加入到HashSet里

  5. 遍历HashSet,打印出10个随机数

package hashset;
 
import java.util.HashSet;
import java.util.Random;
 
public class Test1_HashSet {
 
	public static void main(String[] args) {
		
		//1.创建Random对象
		Random r = new Random();
		//2.创建HashSet对象
		HashSet<Integer> hs = new HashSet<>(); 	//注意是包装类不是int
		//3.判断并添加元素
		while(hs.size()< 10) {
			//4.通过Random中随机方法nextInt()获取1到20范围内随机数
			hs.add(r.nextInt(20) + 1); 		//如果不加1,随机范围是0到19
		}
		
		//5.遍历HashSet
		for (Integer integer : hs) {
			System.out.println(integer);
		}
	}

二、从键盘获取一行输入字符串,要求去除重复字符。

分析过程:

  1. 需要使用Scanner类

  2. 输入的是一行字符串,需要转换成字符数组

  3. 创建HashSet集合对象(利用HashSet无法储存相同元素的特性达到去除重复字符的目的)

  4. 字符数组遍历元素,并添加进入HashSet集合

  5. 变量集合元素

package hashset;
 
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
 
import javax.swing.plaf.synth.SynthSpinnerUI;
 
public class Test2_HashSet {
 
	public static void main(String[] args) {
		
		//1.创建键盘输入对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一行字符串:");
		String line = sc.nextLine();
		
		//2.字符串转换成字符数组
		char[] c = line.toCharArray();
		
		//3.字符数组转换成集合对象,创建HashSet
		HashSet<Character> hs = new HashSet<>();
	
		//4.遍历数组,元素依次添加进集合
		for (int i = 0; i < c.length; i++) {
			hs.add(c[i]);
		}
		
		//5.遍历HashSet集合
		for (Character character : hs) {
			System.out.println(character);
		}
		
	}
 
}

三、假设顺序列表ArrayList中存储的元素是整型数字1~5,遍历每个元素,将每个元素顺序输出。(list集合遍历方法总结)

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
//假设顺序列表ArrayList中存储的元素是整型数字1~5,遍历每个元素,将每个元素顺序输出。 [必做题]
public class MyArray {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        Iterator<Integer> it = list.iterator();
//      迭代器遍历
        while(it.hasNext()){
            System.out.println(it.next());
        }
//      for循环遍历
        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
//      增强for循环
        for(Integer i :list){
            System.out.println(i);
        }
    }

四、在一个列表中存储以下元素:apple,grape,banana,pear

• 3.1 返回集合中的最大的和最小的元素

• 3.2 将集合进行排序,并将排序后的结果打印在控制台上

package txtt;
import java.util.*;
//3、在一个列表中存储以下元素:apple,grape,banana,pear 
//• 3.1 返回集合中的最大的和最小的元素 
//• 3.2 将集合进行排序,并将排序后的结果打印在控制台上 
public class test4 {
	public static void main(String[] args) {
					
			HashSet<String> set = new HashSet<>();		
			set.add("apple");
			set.add("grape");
			set.add("banana");
			set.add("pear");
			String max = Collections.max(set);
			
			System.out.println(max);
			String min = Collections.min(set);
			
			System.out.println(min);
			
			for(Object o:set) {
				System.out.print(o+" ");
			}
		}
	
	}


五、编写程序,获取命令行参数中的字符串列表,输出其中重复的字符、不重复的字符以及消除重复以后的字符列表。

ublic static void main(String[] args) {
    String str = "abcdeafblmbnopawc";
    System.out.println("原字符串:"+str);
 
 
    Set<Character> set1 = new HashSet<Character>();//消除重复后的字符
    Set<Character> set2 = new HashSet<Character>();//重复的字符
    Set<Character> set3 = new HashSet<Character>();//不重复的字符
 
    //把字符串转为字符数组
    char[] cs = str.toCharArray();
    for (char c : cs) {
        boolean b = set1.add(c);
        if(!b){
            set2.add(c);
        }
    }
 
    //把消除重复后的字符赋给set3
    set3.addAll(set1);
    //把消除重复后的字符 - 重复的字符 = 不重复的字符
    set3.removeAll(set2);
 
    System.out.println("====消除重复后的字符========");
    for (char c : set1) {
        System.out.print(c+" ");
    }
 
    System.out.println("\n====重复的字符========");
    for (char c : set2) {
        System.out.print(c+" ");
    }
 
    System.out.println("\n====不重复的字符========");
    for (char c : set3) {
        System.out.print(c+" ");
    }
 
 
}

六、使用Scanner从控制台读取一个字符串,统计字符串中每个字符出现的次数,要求使用学习过的知识完成以上要求

实现思路根据Set、List、Map集合的特性完成。

public static void main(String[] args) {
    String str = "abcdeblmbac";
    System.out.println("原字符串:"+str);
 
    Map<Character,Integer> map = new HashMap<Character,Integer>();
    char[] cs = str.toCharArray();
 
    for (char c : cs) {
 
        if(map.containsKey(c)){
            Integer value = map.get(c);
            value++;
 
            map.put(c, value);
 
        }else{
            map.put(c, 1);
        }   
    }
    //遍历map
    Set<Character> set = map.keySet();
    for (Character c : set) {
        System.out.println(c+"出现了"+map.get(c)+"次");
    }
}

七、 写一个Student类, 包含属性id[1-30), grade[1-6], score[0-100], 所有属性都是随机生成

// 创建一个Set集合, 保存20个对象, 如果两个对象的id是一样的,则不允许添加.
// 使用迭代器遍历集合,打印输出对象的信息, 并找出分数最高的同学和分数最低的同学, 最后打印输出最高分和最低分同学信息.

package txtt;

import java.util.*;

public class Test13 {
	public static void main(String[] args) {
		Set<Student> set = new TreeSet<Student>();
		for (; set.size() != 20;) {
			int id = (int) (Math.random() * 29 + 1);
			int grade = (int) (Math.random() * 6 + 1);
			double score = (int) (Math.random() * 1001) / 10.0;
			set.add(new Student(id, grade, score));
		}
		for (Student student : set) {
			System.out.println(student);
		}
		System.out.println("---------------------------");
		Object[] array =  set.toArray();
		
		System.out.println("max:"+array[0]);
		System.out.println("min:"+array[array.length-1]);
		
}
}
 
class Student implements Comparable<Student> {
 
	private int id;
	private int grade;
	private double score;
 
	public Student() {
	}
 
	public Student(int id, int grade, double score) {
		super();
		this.id = id;
		this.grade = grade;
		this.score = score;
	}
 
	public int getId() {
		return id;
	}
 
	public void setId(int id) {
		this.id = id;
	}
 
	public int getGrade() {
		return grade;
	}
 
	public void setGrade(int grade) {
		this.grade = grade;
	}
 
	public double getScore() {
		return score;
	}
 
	public void setScore(double score) {
		this.score = score;
	}
 
	@Override
	public String toString() {
		return "Student [id=" + id + ", grade=" + grade + ", score=" + score + "]";
 
	}
 
	public int compareTo(Student o) {
		return (int) (this.score - o.score);
	}
 


}

附:选择

image

部分图来自网络,习题来自https://blog.csdn.net/Andrelia20171760/article/details/85268422

这篇关于【Java】集合与数组关系,认识集合,使用集合,集合使用判断情况的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!