容器

最新推荐文章于 2024-06-10 16:10:03 发布

WZHATxY

最新推荐文章于 2024-06-10 16:10:03 发布

阅读量189

点赞数 1

分类专栏：总结文章标签： java

本文链接：https://blog.csdn.net/WZHATxY/article/details/96494058

版权

总结专栏收录该内容

6 篇文章 0 订阅

订阅专栏

容器的特点：**

												用来放置对象或基本类型数据。当容器容量不足时可以进行自动扩容增加容量，更加灵活方便。

容器和数组的区别：

								数组的长度一旦确定不可改变，不灵活容量需要提前定义好，不能随着需求的变化而扩容。
								数组： 1.数据类型要求一致
											2.有序有索引
											3.定长
								容器：存储任意类型的数据，容器大小随着内容的数量进行增减。容器是类内部可以通过数组实现功能，
								可以有添加数数据、删除、修改、长度、获取。

如何使用容器：

							一、容器的添加功能
								1.定义容器类
								2.定义存储容器内容的数组
								3.定义容器对象存储的数据个数
								4.定义添加容器内容的功能
								5.重新定义一个新的数组对象备份原数组
								6.原数组指向新的数组内容，注意新数组长度为容器对象存储的数据个数加一
								7.数组的拷贝，数组的循环索引
							
								二、容器的添加功能
									1.定义获取方法
									2.判断是否出现数组越界异常，当出现异常时报错，没有出现越界异常时返回原数组索引的内容
									3.调用获取方法获取数组索引内容
									4.注意数组越界异常（ArrayIndexOutOfBoundsException(index+"越界了亲~~~")）***
								
								三、删除容器内容
									1.根据索引删除
									2.定义一个删除方法
									3.备份原数组
									4.原数组指向一个新的数组，当删除是原数组长度要减一
									5.原数组索引位置删除前的数据原封不动的拷贝到新数组相同的位置，删除位置后面的数据放置到新数组的减一后的位置
									6.注意删除的位置等于索引位置的时候不需要拷贝数据

**

## 代码块

**						
								package com.shstx.rongqi;
									
									import java.util.Arrays;
									
									public class RongQi {
										public static void main(String[] args) {
											MyContainer my=new MyContainer();
											my.add("钢铁侠");
											my.add("蜘蛛侠");
											my.add("绿巨人");
											my.add("键盘侠");
											System.out.println(my);
											//获取方法
											System.out.println(my.get(0));
											//删除数据方法
											my.remove(1);
											System.out.println(my);
											//
											System.out.println(my.alter(0,"1"));
										}
									}
									class MyContainer{
										private String[] arr;//存储容器的数据的数组
										private int size;//容器对象存储的数据个数
										
										//构造器中赋值
										public MyContainer() {
										   arr=new String[0];
										}
										//添加功能
										public void add(String value){
											//备份原数组
											String[] temp=arr;
											//arr指向新的数组
											arr=new String[size+1];
											//数组的拷贝 i控制原数组和新数组的索引
											for(int i =0;i<size;i++){
												arr[i]=temp[i];
											}
											arr[size]=value;
											size++;
										}
										//打印toString
										@Override
										public String toString() {
											return "MyContainer [arr=" + Arrays.toString(arr) + ", size=" + size + "]";
										}
										//获取方法 根据索引获取数据
										public String get(int index) {
											//判断获取是否越界
											if(index<0||index>=size){
												throw new ArrayIndexOutOfBoundsException(index+"以越界！！");
											}
											return arr[index];		
										}
										//删除容器数据方法
										public void remove(int index) {
											//越界异常
											if(index<0 || index>=size){
												throw new ArrayIndexOutOfBoundsException(index+"越界了亲~~~");
											}
											//备份原来的数据
											String[] temp = arr;
											//指向新的数组对象
											arr=new String[size-1];
											//i代表原数组数据的索引
											for(int i=0;i<size;i++){
												//判断删除前后的拷贝
												if(i>=index){
													if(i==index){
														continue;
													}
													arr[i-1]=temp[i];
												}else{
														arr[i]=temp[i];
													}
												}
											size--;//删除数据后容器对象数据存储的个数减一
										}
									}

					Colletion接口是一组允许重复的对象
									Set 接口继承Colletion，无序不重复
									List 接口继承Colletion，有序允许重复。
									Map 接口一组成对的键值对象，Map中不能有重复的key.
									注意：容器中的内容都为引用数据类型，不能放置原生数据类型（int String	....），使用泛型保留数据*************
					Collection下的方法
					1.aad（E e）返回值boolean  作用添加元素
					2.size() 返回值 int 容器的大小
					3.contains(Object o) boolean 包含(引用类型重写equals)
					4.isEmpty() boolean 容器是否为空
					5.equals(Object o) boolean 比较两个容器内容是否相同
					6.remove(Object o) boolean 删除元素(重写equals) D
					7.clear() void 清空容器
					8.toArray() Object[] 所有元素存放数组中 其他
					9.toArray(T[] a) <T> T[]
					10.retainAll(Collection<?> c) 
					11.boolean 求交集
					12.iterator() Iterator 遍历 遍历
					13.增强for遍历
					注意：使用增强for一定要给Collection泛型
					注意：iteratoe（）两种迭代器的使用while循环和 for循环 ***********
					注意：toArry()返回的是数组

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
/*	4.isEmpty() boolean 容器是否为空
	5.equals(Object o) boolean 比较两个容器内容是否相同
	6.remove(Object o) boolean 删除元素(重写equals) D
	7.clear() void 清空容器
	8.toArray() Object[] 所有元素存放数组中 其他
	9.toArray(T[] a) <T> T[]
	10.retainAll(Collection<?> c) 
	11.boolean 求交集
	12.iterator() Iterator 遍历 遍历
*/


public class RongQi01 {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		String[] arr = null ;
		Collection<String> col=new ArrayList();
		Collection<String> coll=new ArrayList(); 
		
		col.add("嘉兴");
		col.add("杭州");
		col.add("诸暨");
		col.add("义乌");
		
		coll.add("钢铁侠");
		coll.add("蜘蛛侠");
		coll.add("緑巨人");
		coll.add("雷神");
		coll.add("键盘侠");
		System.out.println(col);
		System.out.println(coll);
		System.out.println("容器的大小："+coll.size());
		System.out.println("容器的大小："+col.size());//容器的大小
		System.out.println(col.contains("嘉兴"));//引用类equal的重写方法
		System.out.println(coll.contains("蜘蛛侠"));
		System.out.println(col.equals(coll));//比较两个容器的内容	
		//coll.remove("键盘侠");//移除键盘侠
		//coll.clear();//清空容器
		System.out.println(coll);
		
		System.out.println(Arrays.toString(coll.toArray()));
		//System.out.println(Arrays.toString(toArray(arr,coll)));
		//System.out.println(Arrays.toString());
		//迭代器的两种使用方法
		//while循环
//		Iterator it =coll.iterator();
//		while(it.hasNext()){
//			System.out.println(it.next());
//		}
//		System.out.println("--------------------------------------------------");
		//for循环
		for(Iterator it =coll.iterator();it.hasNext(); ){
			System.out.println(it.next());
		}
		//增强for遍历注意泛型
		for（Sting s:col）{
		 System.out.println(s);
		}
	}

泛型
为什么需要泛型？
 JDK1.4 以前类型不明确：
 装入集合的类型都被当作 Object 对待，从而失去自己的实际类型。
 从集合中取出时往往需要转型，效率低，容易产生错误。

		泛型的好处：
		增强程序的可读性和稳定性。
		注意：使用泛型，保留了容器中元素的类型，安全省心的使用容器。注意:没有必要引入泛型
		的复杂性。

List 接口
List 有序的Collection，有序的可重复的
List接口新增的方法操作索引功能
add（index，值），indexOf（object），remove（索引），set（index，数据），get（索引）
ArrayList
ArrayList 是 List 的子类，它和 HashSet 想法，允许存放重复元素，因此有序。集合中元
素被访问的顺序取决于集合的类型。如果对 ArrayList 进行访问，迭代器将从索引 0 开始，
每迭代一次，索引值加 1。然而，如果访问 HashSet 中的元素，每个元素将会按照某种随机
的次序出现。虽然可以确定在迭代过程中能够遍历到集合中的所有元素，但却无法预知元
素被访问的次序。

LinkedList
LinkedList 是一种可以在任何位置进行高效地插入和删除操作的有序序列

LinkedList：底层用双向链表实现的 List。特点：查询效率低，增删效率高，线程不安全。
ArrayList：底层用数组实现的 List。特点：查询效率高，增删效率低，线程不安全。
Vector：底层用数组实现的 List，特点：线程安全。

HashMap
可以说是 Java 中最常用的集合类框架之一，是 Java 语言中非常典型的数据结
构，我们总会在不经意间用到它，很大程度上方便了我们日常开发。实现 Map 接口的类用
来存储键(key)－值(value) 对，Map 类中存储的键－值对通过键来标识，所以键值不能重复。
Map 接口的实现类有 HashMap 和 TreeMap 等。
 HashMap: 线程不安全，效率高. 允许 key 或 value 为 null
 HashTable:线程安全，效率低. 不允许 key 或 value 为 null
 Properties: Hashtable 的子类，key 和 value 都是 string