javaSE容器

最新推荐文章于 2023-05-26 14:57:03 发布
最新推荐文章于 2023-05-26 14:57:03 发布
阅读量1k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java基础 文章标签： linkedlist 迭代器 hashmap 泛型 java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/liyong_/article/details/13751785
本文深入解析Java中常用容器接口的功能，包括集合、映射、排序、迭代器、泛型、Map接口及其应用实例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 

 一、常用的容器接口：

1、一个图：collection(set,list);map;
2、set接口：无序不可重复；两个实现类：HashSet,TreeSet;
      格式：Set s=new HashSet();
      方法:add(Object o)仅有一个方法,retain(),
3、list接口：有序可重复；两个实现类：LinkedList,ArrayList;
      格式：List l=new LinkedList();List l=new ArrayList();
      方法：add(Object o);add(int i,Object o)；
      l.add(1);表示往里面添加1；
      l.add(1,3)；表示往容器第二个位置添加3；
      remove(int i),remove(非整型）；
      l.remove(1);表示删除容器第二个元素；
      l.remove("2")；表示删除容器内“2”的元素；
      l.set(int i,object o);
      l.set(2,4):表示把容器第三个元素替换成4；
4、Arrays排序和arraycopy();
     作用：针对数组排序问题，只有升序排序；
     运用：Arrays.sort(目标数组);
     输出：System.out.println(Arrays.toString(目标数组));
     arraycopy(源数组，源数组的起始位置，目标数组，目标数     组的起始位置，需要复制的数组长度)；
5、打包和解包：
      定义：将基础类型转换成对象，这种叫打包；
                 将对象转换成基础类型，这种叫解包；
      例子：
      int a=100;
      Integer i=new Integer(a);//此时就叫打包；
      int b=i/new Integer(a);//此时就叫解包
6、Iterator接口：
     作用：简称迭代器，功能是遍历；
     方法：hasNext(),next(),remove();
     例子：
      Collection c=new ArrayList();
      c.add()......;如果这样是int型
      Iterator i=c.iterator();
      while(i.hasNext()){
         Integer in=(Integer)i.next();
}
7、泛型：（基础篇）
     格式：用<>加类型：<除基本类型除外>
8、Map接口：
     格式：Map(K,V);
     HashMap:无序，不可重复；
     TreeMap:按K键的大小来输出，同样不可重复；
     LinkedHashMap:按照代码先后顺序输出；
9、equals()与hashcode():
     作用：equals()比较是两个对象的值是否相等；
                hashcode()比较两个对象是否是同一个对象；

10、  Array读快改慢  
          Linked改快读慢

         Hash搜索极快，遍历极慢

         Tree插入/搜索都比较快，适合做索引

      

package test;

import java.util.*;

public class It2 {
	public static void main(String[] args) {
		Collection<Integer> c=new HashSet<Integer>();
		c.add(1);
		c.add(2);
		c.add(3);
		c.add(4);
		System.out.println(c);
		Iterator<Integer> i=c.iterator();
		while(i.hasNext()){
			int a=i.next();
			System.out.print(a);
		}
	}
}
输出结果：
[1, 2, 3, 4]
1234
package test;

import java.util.Arrays;

public class test {
	public static void main(String[] args) {
	int [] i={1,5,6,9,3,6};
	int [] m={2,3,4,4};
	String [] s={"2","1"};
	Arrays.sort(s);
	for (String a:s){
		System.out.println(a);
	}
		System.out.println(Arrays.toString(i));
		
		System.arraycopy(i,1,m,0,3);
		System.out.println(Arrays.toString(m));

	}
}
输出结果：
1
2
[1, 5, 6, 9, 3, 6]
[5, 6, 9, 4]
package test;

class Fanxing<T, V> {

	Fanxing(T name, V age) {
		this.age = age;
		this.name = name;
	}

	private T name;
	private V age;

	public T getName() {
		return name;
	}

	public V getAge() {
		return age;
	}

	public String toString() {
		return this.getName() + "  " + this.getAge();
	}

	public static void main(String[] args) {
		Fanxing<String, Integer> he = new Fanxing<String, Integer>("Rollen", 12);
		System.out.println(he.toString());

	}
}
输出结果：
Rollen  12
package test.cn;

import java.util.*;

public class Test03 {
	public static void main(String[] args) {
		Map<String,Integer> m=new LinkedHashMap<String,Integer>();
		m.put("小黄", 25);
		m.put("小米", 22);
		m.put("小话", 24);
		m.put("小花", 21);
		System.out.println(m);
	}

}

输出结果： 
{小黄=25, 小米=22, 小话=24, 小花=21}
package test.cn;
import java.util.*;

public class Test03 {
	public static void main(String[] args) {
		Map<String,Integer> m=new TreeMap<String,Integer>();
		m.put("小黄", 25);
		m.put("小米", 22);
		m.put("小话", 24);
		m.put("小花", 21);
		System.out.println(m);
	}

}

输出结果： 
{小米=22, 小花=21, 小话=24, 小黄=25}
第一题：
package com.baidu.cn;

public class Name {
    private String firstName,lastName;
    public Name(String firstName, String lastName) {
        this.firstName = firstName; 
        this.lastName = lastName;
    }
    public String getFirstName() {  
    	return firstName;  
    }
    public String getLastName() {   
    	return lastName;   
    }
    public String toString() {  
    	return firstName + ""+ lastName; 
    }
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((firstName == null) ? 0 : firstName.hashCode());
		result = prime * result
				+ ((lastName == null) ? 0 : lastName.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Name other = (Name) obj;
		if (firstName == null) {
			if (other.firstName != null)
				return false;
		} else if (!firstName.equals(other.firstName))
			return false;
		if (lastName == null) {
			if (other.lastName != null)
				return false;
		} else if (!lastName.equals(other.lastName))
			return false;
		return true;
	}
    
    
}
第二题：
package com.baidu.cn;

import java.util.*;

public class Test {

	public static void main(String[] args) {
       ArrayList al=new ArrayList();
       al.add(12);al.add(25);al.add(58);al.add(69);al.add("147");
       System.out.println(al);
       al.remove(1);
       System.out.println(al);
       al.remove("147");
       System.out.println(al);


	}

}
第三题：
package com.baidu.cn;

public class Test1 {

	public static void main(String[] args) {
		int a=100;
		Integer i=new Integer(a);
		System.out.println(i);
		 
		//解包
		int b=new Integer(a);
		System.out.println(b);

	}

}
第四题：
package com.baidu.cn;

import java.util.*;

public class Test2 {

	public static void main(String[] args) {
		Collection<Integer> c=new HashSet<Integer>();
		c.add(1);c.add(2);c.add(7);c.add(8);
		for(int d:c){
			System.out.println(d);
		}
//		System.out.println(c);
		
//		Iterator<Integer> i=c.iterator();
//		while(i.hasNext()){
//			Integer n= i.next();
//			System.out.println(n);
//		}

	}

}
第五题：
package com.baidu.cn;

import java.util.*;

public class Test3 {

	public static void main(String[] args) {
		 Map m=new TreeMap();
		 m.put(1, 2);
		 m.put(1, 2);
		 m.put(5, 6);
		 m.put(2, 3);
		 m.put(0, 6);
		 m.put(3, 10);
		 m.put(78, 3);
		 m.put(41, 2);
		 System.out.println(m);
	}

}
第六题：一个5位数，判断它是不是回文数。即12321是回文数，
      个位与万位相同，十位与千位相同。
package com.baidu.cn;

import java.util.Scanner;
/*
 * toCharArray();它可以把字符串类型转换成字符数组；
 */
public class Test4 {
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		System.out.println("请输入数字：");
		int a=s.nextInt();
		while(a>=10000 && a<=99999){
			String str=String.valueOf(a);
			char[] ch=str.toCharArray();
			if(ch[0]==ch[4] && ch[1]==ch[3]){
				System.out.println(str+"是回文数");
			}else{
				System.out.println("不是回文数");
			}
			break;
		}

	}

}
第七题：一个5位数，判断它是不是回文数。即12321是回文数，
       个位与万位相同，十位与千位相同。
package com.baidu.cn;

import java.util.Scanner;

public class Test5 {
   public static void main(String[] args) {
	  Scanner s=new Scanner(System.in);
	  System.out.println("请输入数字：");
	  int a=s.nextInt();
	  while(a>=10000 && a<=99999){
		  String str=String.valueOf(a);
		  StringBuffer sb=new StringBuffer(str);
		  StringBuffer s2=sb.reverse();
		  String m=String.valueOf(s2);
		  if(str.equals(m)){
			  System.out.println("是回文数");
		  }else{
			  System.out.println("不是回文数");
		  }
		  
		  System.out.println(s2);
		  break;
	  }
}
}
第八题：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...
       求出这个数列的前20项之和。
package com.baidu.cn;

public class Test6 {
   public static void main(String[] args) {
	  double a=2.0,b=1.0;
	  double sum=0;
	  for(int i=1;i<=20;i++){
		  sum=sum+a/b;
		  a=a+b;
		  b=a-b;
	  }
	  System.out.println(sum);
}
}
第九题：
package com.baidu.cn;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test7 {
   public static void main(String[] args) {
	  String s="123abcd22xyz45";
//	  Pattern p=Pattern.compile("\\d");
//	  Matcher m=p.matcher(s);
//	  int sum=0;
//	  while(m.find()){
//		  String n=m.group();
//		  Integer i=Integer.parseInt(n);
//		  sum=sum+i;
//	  }
//	  System.out.println(sum);
	  int sum=0;
	  for(int i=0;i<s.length();i++){
		  char c=s.charAt(i);
		  if(Character.isDigit(c)){
			  sum=sum+(c-48);
		  }
	  }
	  System.out.println(sum);	  	  
}
}




 

Java学习-Set容器
qq_43530224的博客
06-25 649
Set容器 Set就是我们数学中的集合，其是无续（与你插入元素顺序不一致）且不能够重复的 Set容器的分类 HashSet:底层由哈希表+红黑树实现，无续（与你插入元素顺序不一致），利用HashSet可以快速查找，效率很高 LinkedHashSet继承HashSet,其底层是哈希表+双向链表，可以实现迭代有序，但其查找效率相对于HashSet,没有其高 TreeSet:底层由红黑树实现，可以实现按照元素的大小写进行排序 之间的继承关系如下： HashSet HashSet底层就是HashMap的KE
javaSE (五)：集合/容器
最新发布
m0_70830675的博客
04-08 1106
Java的集合框架是由很多接口、抽象类、具体类组成的，都位于java.util包中。
javase之容器
Richard_666的博客
02-17 210
接口是一种规范 list：有序、可以重复 set：无序、不可重复 map：键值对，唯一的键，通过一个对象找另一个对象（通过你找你的老婆） null：表示篮子都没有 empty：表示有篮子，没有放苹果  ...
JavaSE之容器
kimlllll的博客
09-27 206
Collection接口，位于Java.util包中 image.png 接口set Api中的解释是：一个不包含重复元素的 collection,更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。Set中的元素没有顺序。 接口List Api中的解释是：有序的 collection（也称为序列）。...
【JavaSE】Java 容器---集合
Mr、黄
09-29 473
集合、数组都是对多个数据进行存储操作的结构，简称 Java 容器说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储一旦初始化，其长度就确定了数组一旦定义好，其元素的类型也就确定了，就只能操作指定类型的数据了一旦初始化，其长度就确定了数组中提供的方法非常有限，对于添加，删除，插入数据等操作，非常不便，同时效率不高获取数组中实际元素的个数的需求，数组没有现成的属性和方法可用数组存储数组的特点：有序，可重复，对于无序，不可重复的需求，不能满足。
Java set容器
qq_41177704的博客
11-11 499
set特点：无序，唯一 HashSet 采用Hashtable哈希表存储结构(神奇的结构) 优点:添加速度快查询速度快删除速度快 缺点:无序 LinkedHashSet 采用哈希表存储结构,同时使用链表维护次序 有序(添加顺序) TreeSet 采用二叉树(红黑树)的存储结构 优点:有序（大小顺序）查询速度比List快(按照内容查询) 缺点:查询速度没有HashSet快 二叉排序树：左子树<根<右子树 二叉平衡树：首先是排序树，左右子树高度差不超过1 set的遍历 for-ea
JavaSE8容器类的UML图(继承自Colletion的所有子类)
11-17
参考JavaSE8，全面囊括了所有Java容器类，以Collection为基类，使用不同颜色不同的继承体系分支进行标识。
王道JavaSE阶段测试
05-31
4. **集合框架**：ArrayList，LinkedList，HashSet，HashMap等容器的理解与使用，泛型，迭代器，List与Set的区别，Map接口及其实现类的特点。 5. **IO流**：字节流与字符流，缓冲流，对象序列化，文件操作，输入...
javase1.8下载
08-23
6. **Optional类**：为了解决null值引发的问题，Java 8引入了`Optional<T>`类，它是一个容器对象，可能包含或者不包含非null值。通过使用`Optional`，可以更好地设计API，减少空指针异常的风险。 7. **默认方法**：...
JavaSE异常处理与容器详解
"JavaSE知识集，包括异常处理机制、容器类、Collection接口、Set和List的区别、Map接口、Iterator接口的使用以及遍历数组和集合的方法。" JavaSE是Java Standard Edition的简称，它是Java平台的核心，主要用于桌面...
java 容器之Set
知之为知之，不知为不知，是知也
05-22 534
容器Set基本特征:     1. 没有顺序, 不可放重复值,的容器.    2. 实现方式为HashMap, 基本为数组加链表基本用法见Demo:public static void main(String[] args){ Set&lt;String&gt; firstSet = new HashSet&lt;String&gt;(); //1.add new element....
Java容器之set
keepstrivingchy的博客
09-04 615
set相关的容器
JavaSE基础知识(二十一)--Java集合(容器)之概述
ruidianbaihuo的博客
10-22 264
Java SE 是什么，包括哪些内容(二十)？ 本文内容参考自Java8标准 再次感谢Java编程思想对本文的启发！ 首先，来看3个问题： 1、如果一个程序只包含固定数量的且其生命周期都是已知的对象，那么这是一个非常简单的程序。 2、Java中的集合(容器)是专门用来存放对象(实际上是对象的引用)的，同时它本身也是一种对象。 3、 一般情况下，我们都是依靠命名的引用来持有对象： MyType ...
javase容器--集合框架
jameslogo的博客
05-12 211
集合是非常重要的类型，和数组一样都是存数据的容器，但不同的是：它不固定大小可动态扩展存取灵活存放类型多样等 集合框架有collection和map两大接口，Collection是传统集合接口，存储单个对象，Map类继承关系为 Collection ├List （有序集合，允许相同元素和null） │├LinkedList （非同步，允许相同元素和null，遍历效率低插入和删除效率高） │├ArrayList （非同步，允许相同元素和null，实现了动态大小的数组，遍历效率高，用的多） │└Vector（
Java：集合容器（set）
qq_48510607的博客
05-01 361
集合就是数学中的集合的概念：所有的元素都具有唯一性，元素在其中没有顺序。 package test; import java.util.ArrayList; import java.util.HashSet; class Value { private int i; public void set(int i) {this.i = i;} public int get() {return i;} public String toString() {return ""+i;} //当直接调用对象
Java SE 07 容器
离开实践的理论是空洞的理论,没有理论指导的实践是盲目的实践
02-03 368
容器：持有事务11361：一个图1：一个类             Collections 封装了一些基于List容器的算法3：三个知识点            Foreach语句            Generic泛型            Autoboxing/unboxing6：六个接口             Collection                   Set       ...
java 容器 set_Java编程用Set容器
weixin_28848933的博客
02-15 258
展开全部importjava.util.ArrayList;importjava.util.Collection;importjava.util.Collections;importjava.util.Comparator;importjava.util.HashSet;importjava.util.Set;/***有10本图书，2个属性：名称和ISBN号，将10本图书存放到一个S...
Java集合（容器）
zhouwenxing666的博客
05-26 697
1​ 集合又称容器。是Java中对数据结构(数据存储方式)的具体实现。​ 我们可以利用集合存放数据，也可以对集合进行新增、删除、修改、查看等操作。​ 集合中数据都是在内存中，当程序关闭或重启后集合中数据会丢失。所以集合是一种临时存储数据的容器。2.​ List和Set接口的父接口, 还有其他的实现类或子接口。​ Collection接口的子接口。Collection中包含的内容List接口中可以继承。​ List专门存储有序，可重复数据的接口。​ 实现了List接口, 底层实现可变长度数组。
Java知识点总结（Java容器-Set）
weixin_34252686的博客
05-31 145
Java知识点总结（Java容器-Set） @(Java知识点总结)[Java, Java容器, JavaCollection, JavaSet] Set Set是一种不包括重复元素的Collection。它维持自己的内部排序，所以随机访问没有任何意义。与List一样，它同样允许null的存在但只能有一个。由于Set接口的特殊性，所有传入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值