java集合

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量123 收藏
点赞数
分类专栏： java基础 文章标签： java 算法 数据结构
一.List接口
1.特点
  1. 有序
  2. 有索引
  3. 可重复，元素可为null
  4. 底层用数组实现
2. ArrayList
2.1 实现
public class MyArrayList {	
	/**
	 * 定义数组，保存数据
	 */
	private Object[] objects = null;
	/**
	 * 默认数组长度
	 */
	private final int DEFAULT_LENGTH = 10;
	/**
	 * 数组长度
	 */
	private int length;
	/**
	 * 数组元素个数
	 */
	private int size= 0;
	/**
	 * 默认构造函数，创建数组
	 */
	private final int LOAD = 2;
	public MyArray() {
		length = DEFAULT_LENGTH;
		objects = new Object[length];
	}
	/**
	 * 构造函数，根据用户传入长度创建数组
	 * @param length
	 */
	public MyArray(int length) {
		this.length = length;
		objects = new Object[length];
	}
	/**
	 * 向数组中添加元素
	 * @param o
	 */
	public void add(Object o) {
		//判断是否需要扩容
		if(size==length) {
			//元素个数等于了数组长度，需要扩容
			length = length*LOAD;
			objects = Arrays.copyOf(objects,length);
		}
		objects[size]=o;
		size++;
	}	
	public void add(int index,Object o) {
		if(index<0||index>size-1) {
			throw new ArrayIndexOutOfBoundsException("访问越界");
		}else {
			//判断是否需要扩容
			if(size==length) {
				//元素个数等于了数组长度，需要扩容
				length = length*LOAD;
				objects = Arrays.copyOf(objects,length );
			}
			//先将index位置处的元素已近后面元素向右移动
			System.arraycopy(objects, index, objects, index+1, size-index);
			objects[index] = o;
			size++;
		}
	}
	/**
	 * 数组移除操作
	 * @param index
	 */
	public void remove(int index) {
		if(index<0||index>size-1) {
			throw new ArrayIndexOutOfBoundsException("访问越界");
		}else {
			objects[index]= null;
			System.arraycopy(objects, index+1, objects,index , size-index);
			size--;
		}
	}
	/**
	 * 	查找元素所在的位置
	 * @param o
	 * @return
	 */
	public int indexOf(Object o) {
//		if(size==0) {
//			return size;
//		}else if(size==length) {
//			return -1;
//		}else if(size<length) {
//			return size;
//		}
		if(o==null) {
			return -1;
		}
		for (int i = 0; i < size; i++) {
			Object object = objects[i];
			if(o.equals(object)) {
				return i;
			}
		}
		return -1;
	}
	/**
	 * 	是否包含某个元素
	 * @param o
	 * @return
	 */
	public boolean contains(Object o) {
		int i = indexOf(o);
		return i>=0?true:false;
	}
	/**
	 * 移除所有元素
	 */
	public void removeAll() {
		Arrays.fill(objects, null);
		size =0;
	}
	/**
	 * 更新数组元素
	 * @param index
	 * @param o
	 */
	public void update(int index,Object o) {
		if(index<0||index>size-1) {
			throw new ArrayIndexOutOfBoundsException("访问越界");
		}
		objects[index] = o;
	}
	/**
	 * 查找某个索引处的元素
	 * @param index
	 */
	public Object get(int index) {
		if(index<0||index>size-1) {
			throw new ArrayIndexOutOfBoundsException("访问越界");
		}
		return objects[index];
	}
	/**
	 * 打印数组元素
	 */
	@Override
	public String toString() {
		StringBuffer sb = new StringBuffer("[");
		for (int i = 0; i < size; i++) {
			sb.append(objects[i]);
			sb.append(",");
		}
		sb.append("]");
		return sb.toString().replace(",]", "]");
	}
	/**
	 * 获取元素个数
	 * @return
	 */
	public int size() {
		return size;
	}
}
2.2 方法
方法描述
add(Object o)添加数据
add(int index,Object o)在制定索引处添加元素
size()获取元素个数
get(int index)获取索引处的元素
isEmpty()判断集合是否为空
indexOf(Object o)判断某个元素第一次出现的位置
E remove(int index)移除索引处元素，并返回该元素
boolean remove(Object o)移除元素
clear()清空元素
set(int index ,E e)修改索引处的元素
iterator()获取迭代器
trimToSize()减少容量指当前元素个数
contains(Object o)判断是否包含某个元素
lastIndexOf(Object o)判断某个元素最后一次出现的位置
toArray()将集合转换为数组
addAll(Collection<? extends E> c)集合中添加集合
addAll(int index, Collection<? extends E> c)索引处添加集合
retainAll(Collection c)求两个集合的交集
removeAll(Collection<?> c)移除传入集合内的元素
subList(int fromIndex, int toIndex)获取子集合
2.3List遍历
public static void main(String[] args) {
		//菱形语法
		ArrayList<Integer> list = new ArrayList<>();
		list.add(1);
		list.add(4);
		list.add(2);
		for (Integer integer : list) {
			System.out.println(integer);
		}
   		//使用迭代器遍历
		Iterator<Integer> it = list.iterator();
		//判断是否有下一个元素
		while (it.hasNext()) {
			int i = it.next();
			System.out.println(i);
		}
}
3.LinkedList
3.1双向链表实现
public class MyLinkedList<E>{
	/**
	 * 链表元素个数
	 */
	private int size;
	/**
	 * 链表首节点
	 */
	private Node first;
	/**
	 * 链表尾结点
	 */
	private Node last;
	/**
	 * 默认构造创建一个空链表
	 */
	public MyLinkedList() {
		first = null;
		last = null;
		size = 0;
	}
	/**
	 * 在链表末尾添加元素
	 * @param e
	 */
	private void linkLast(E e) {
		if(first==null||last==null||size==0) {
			//说明链表为空链表
			//1.创建新节点
			//2.新节点指为first
			//3.新节点指为last
			Node<E> newNode = new Node(null,e,null);
			first = newNode;
			last = newNode;
		}else {
			
			//1.创建新节点
			Node<E> newNode = new Node(last,e,null);
			//2.将last节点指向新节点
			last.next = newNode;
			//3.将新节点改为last
			last = newNode;
		}
		size++;
	}
	
	/**
	 * 在链表首部添加节点
	 * @param e
	 */
	private void linkFirst(E e) {
		if(first==null) {
			//1.创建新节点
			Node<E> newNode = new Node<E>(null, e, null);
			first = newNode;
			last = newNode;
		}else {
			Node<E> newNode = new Node<E>(null, e, first);
			first.pre = newNode;
			first = newNode;
			
		}
		size++;
	}
	/**
	 * 在节点之前添加节点
	 * @param index
	 * @param e
	 */
	private void linkBefore(int index,E e) {
		chcekRange(index);
		//1.创建新节点
		Node<E> node = new Node(null,e,null);
		//2.找到索引处的节点
		Node<E> indexNode = getNodeByIndex(index);
		//3.找到索引处的前置节点
		Node<E> pre = indexNode.pre;
		//4.新节点指向前置节点
		node.pre = pre;
		//5.前置节点指向新节点
		pre.next = node;
		//6.新节点指向索引处节点
		node.next = indexNode;
		//7.索引处pre指向新节点
		indexNode.pre=node;
		size++;
	}
	/**
	 * 在某个节点后插入新节点
	 * @param index
	 * @param e
	 */
	private void linkAfter(int index,E e) {
		chcekRange(index);
		//1.获取当前索引处的节点
		Node<E> indexNode = getNodeByIndex(index);
		//2.获取索引处后置节点
		Node<E> next = indexNode.next; 
		//3.创建新节点
		Node<E> newNode = new Node(indexNode,e,next);
		//4.索引处节点指向新节点
		indexNode.next = newNode;
		//5.索引处节点的后置节点指向新节点
		next.pre = newNode;
		size++;
	}
	
	/**
	 * 链表中添加节点，默认添加在尾部
	 * @param e
	 */
	public void add(E e) {
		linkLast(e);
	}
	/**
	 * 在指定索引处后面添加节点
	 * @param index
	 * @param e
	 */
	public void add(int index,E e) {
		linkAfter(index, e);
	}
	/**
	 * 删除索引处节点
	 * @param index
	 * @return
	 */
	public boolean remove(int index) {
		chcekRange(index);
		if(index==0) {
			Node<E> removeNode = first;
			first = first.next;
			first.pre = null;
			removeNode.next=null;
		}else if(index==size-1) {
			Node<E> removeNode = last;
			last = last.pre;
			last.next = null;
			removeNode.pre = null;
		}else {
			//1.找到索引处的节点
			Node<E> indexNode = getNodeByIndex(index);
			//2.找到索引处的后置
			Node<E> next = indexNode.next;
			//3.找到索引处的前置节点
			Node<E> pre = indexNode.pre;
			//4.将索引处前置节点的next指向索引处后置节点
			pre.next = next;
	 		//5.将索引处后置节点的pre指向索引处前置节点
			next.pre = pre;
			//6.减少元素个数
		}
		size--;
		return true;
	}
	
	/**
	 * 根据索引获取元素
	 * @param index
	 * @return
	 */
	public E get(int index) {
		chcekRange(index);
		Node<E> node = getNodeByIndex(index);
		return node.data;
	}
	/**
	 * 修改索引处的值
	 * @param index
	 * @param e
	 */
	public void set(int index,E e) {
		chcekRange(index);
		Node<E> current  = first;
		
		for (int i = 0; i < size&&current!=null;i++,current = current.next) {
			if(i==index) {
				current.data = e;
			}
		}
	}
	/**
	 * 清空链表
	 */
	public void clear() {
		first =null;
		last =null;
		size=0;
	}
	/**
	 * 链表是否为空
	 * @return
	 */
	public boolean isEmpty() {
		return size==0;
	}
	
	/**
	 * 根据传入的索引找到节点
	 * @param i
	 * @return
	 */
	private Node<E> getNodeByIndex(int index){
		//判断索引越界
		if(index<0||index>size) {
			throw new IndexOutOfBoundsException("访问越界");
		}
		if(index==0) {
			return first;
		}else if(index==size-1) {
			return last;
		}else {
			Node<E> current = first;
			for (int i = 0; i < size&&current!=null; i++) {
				if(i==index) {
					return current;
				}
				current = current.next;
			}
			
		}
		return first;
	}
	/**
	 * 判断访问是否越界
	 * @param index
	 */
	public void chcekRange(int index) {
		if(index<0||index>size-1) {
			throw new IndexOutOfBoundsException("访问越界");
		}
	}
	/**
	 * 打印链接
	 */
	@Override
	public String toString() {
		if(size==0) {
			return "[]";
		}
		Node<E> current = first;
		StringBuffer sb =new StringBuffer("[");
		for (int i = 0; i < size&&current!=null; i++,current=current.next) {
			sb.append(current.data);
			if(i!=size-1) {
				sb.append(",");
			}
		}
		sb.append("]");
		return sb.toString();
		
	}
	
	/**
	 *  定义非静态内部类表示节点
	 * @author MR.W
	 *
	 * @param <E>
	 */
	class Node<E>{
		Node<E> pre;
		E data;
		Node<E> next;
		public Node(Node<E> pre, E data, Node<E> next) {
			super();
			this.pre = pre;
			this.data = data;
			this.next = next;
		}
	}
	
}
3.2 方法
方法描述
add(Object o)添加数据
add(int index,Object o)在制定索引处添加元素
size()获取元素个数
get(int index)获取索引处的元素
isEmpty()判断集合是否为空
indexOf(Object o)判断某个元素第一次出现的位置
E remove(int index)移除索引处元素，并返回该元素
boolean remove(Object o)移除元素
clear()清空元素
set(int index ,E e)修改索引处的元素
addFirst(E e)链表首部添加元素
addLast(E e)链表末尾添加元素
removeFirst()移除首节点
removeLast()移除尾节点
getFirst()获取第一个节点
getLast()获取最后一个几点
二.Set接口
1.特点
  1. 无序
  2. 无索引
  3. 不可重复
2.HashSet
2.1方法
方法描述
add(Object o)添加元素
remove(Object o)移除元素
isEmpty()判断元素是否为空
2.2.HashSet遍历
public class Test {
	public static void main(String[] args) {	
		Set<String> set = new HashSet<>();
		//添加元素
		set.add("陈忠实");
		set.add("贾平凹");
		set.add("路遥");
		set.add("张爱玲");
		set.add("林徽因");
		boolean a = set.add("徐志摩");
		System.out.println(a);
		boolean b = set.add("徐志摩");
		System.out.println(b);
		//foreach
		for (String s : set) {
			System.out.println(s);
		}
		//iterator
		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}
	}
}
2.3重写hashCode规则
  1. 同一对象多次调用hashCode()方法时，返回值应该相同
  2. equals()方法返回值为true时，hashCode应该相同
  3. 所有参与equals方法的成员变量，都应该参与hashCode计算（为防止偶然和相等，造成hash冲突，应该用每个成员变量乘以一个质数）
3.TreeSet
  1. TreeSet内添加对象的类必须实现Comparable接口并重写compareTo方法
  2. TreeSet通过compareTo方法判断两个对象是否相等
  3. 如果equals方法返回true,compareTo方法应该返回0
三.Map接口
1.HashMap
1.1方法
方法描述
put(K key,V value)添加键值对
get(Object key)根据键获取值
keySet()获取keySet
entrySet()获取entrySet
clear()清空
containsKey(Object key)判断是否存在key
remove(Object key)根据key删除键值对
remover(Object key,Object value)根据key和value删除键值对
size()获取元素个数
isEmpty()判断map是否为空
1.2HashMap遍历
//利用keySet()方法获取keySet
public static void main(String[] args) {
	Map<String,Integer> map = new HashMap<String, Integer>();
	map.put("阿紫",30);
	map.put("梦郎", 20);
	map.put("李秋水", 20);
	map.put("天山童姥", 60);
	map.put("梦姑",18);
	//先获取keySet
	Set<String> set = map.keySet();
	//获取迭代器
	Iterator<String> it = set.iterator();
	//利用迭代器遍历
	while (it.hasNext()) {
		String key = it.next();
		int i = map.get(key);
		System.out.println("key==========="+key);
		System.out.println("value========="+i);
	}
}
//利用entrySet()获取entrySet
public static void main(String[] args) {
	Map<String,Integer> map = new HashMap<String, Integer>();
	map.put("乔峰",30);
	map.put("虚竹", 20);
	map.put("李秋水", 20);
	map.put("天山童姥", 60);
	map.put("梦姑",18);
	//获取键值对集合
	Set<Entry<String, Integer>> set = map.entrySet();
	//遍历set
	for (Entry<String, Integer> entry : set) {
		String key = entry.getKey();
		Integer value = entry.getValue();
		System.out.println("key=========="+key);
		System.out.pintln("key=========="+value);
	}
}
1.3HashMap和Hashtable的 区别
  1. HashMap和Hashtable都是Map接口的子类
  2. HashMap的key和value都可以为null，只能存入一个为null的key,Hashtable的key和value都不能为null
  3. HashMap非线程安全，Hashtable线程安全
  4. HashMap数组初始长度为16，Hashtable初始长度为11
2.TreeMap
  1. key有序
  2. key必须实现Comparable接口，并重写comparableTo方法
四.面试题

  1. ArrayList，Vector，LinkedList的区别

    1. ArrayList,Vector底层实现是数组，LinkedList底层实现是双向链表
    2. Vector线程安全，ArrayList，LinkedList非线程安全
    3. ArrayList,Vector查找快，增删慢，LinkedList增删快，查找慢
    4. ArrayList，Vector，LinkedList都是List接口的实现类
    5. ArrayList，Vector，LinkedList都有序，有索引，可重复。

  2. 请简述ArrayList和Vector的区别

    1. ArrayList和Vector底层都是Object数组，查找快，增删慢
    2. ArrayList和Vector都继承了List接口
    3. ArrayList调用默认无参构造是，创建一个长度为0的空数组，当添加第一个元素时数组长度扩展为10，Vector调用默认无参构造时创建一个长度为10的空数组
    4. ArrayList扩容后数组为原长度的1.5倍，Vector扩容后数组长度为原长度的2倍
    5. ArrayList是非线程安全，Vector是线程安全的，但是效率低于ArrayList

  3. 请简述ArrayList和LinkedList的区别

    1. 都继承了List接口
    2. 都是非线程安全
    3. ArrayList底层实现是数组，LinkedList底层实现是双向链表
    4. ArrayList查找快，增删慢，LinkedList 增删快，查找慢
myl824011402
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java集合相减_Java集合的运算之减法A-B
weixin_29580355的博客
02-16 3007
import com.sun.media.sound.SoftSynthesizer;import java.util.*;public class a123 {public static void main(String args[]) {int m, n;Scanner in = new Scanner(System.in);while ((m = in.nextInt()) != 0 | (...
Java集合
06-13
Java的集合类是一种特别有用的工具类，它可以用于存储数量不等的多个对象，并可以实现常用数据结构，如栈，队列等，除此之外，Java集合还可用于保存具有映射关系的关联数组。 Java的集合大致上可分为：Set,List和...
Java集合特点
m0_68206534的博客
03-26 4242
1、基本语法 这包括static、final、rtransient等关键字的作用，foreach循环的原理等等。 2、集合 基本上就是List、Map、Set，问的是各种实现类的底层原理，实现类的优缺点 List集合：有序集合，用户可以精确控制列表中每个元素的插入位置。用户也可以通过整数索引访问元素，并搜索列表中的元素。与Set集合不同，列表通常允许重复元素。 ArrayList的底层数据结构是数组 特点： 索引查询速度最快；长度可以自动动态变化 添加和删除元素效率低；按照内容查询需要逐个比
Java集合底层原理
小凯的博客
03-04 2538
Java集合框架的体系结构、集合架构中的类、算法、底层原理
java集合（超详细）
热门推荐
zdl66的博客
08-12 5万+
所有的集合类和集合接口都在java.util包下。 在内存中申请一块空间用来存储数据，在Java中集合就是替换掉定长的数组的一种引用数据类型。
Java集合去重
qq_41053971的博客
04-21 7265
在日常工作中，我们时常会遇到需要对数据进行遍历去重的操作，笔者便将自己所熟知的几种方法分享给大家。 首先模拟一个实体类，并创建一个main方法调用。 public static void main(String[] args) { List<User> list = new ArrayList(4); list.add(new User("张三","杭州")); list.add(new User("李四","上海")); .
java集合（详解）
abc98526的博客
04-24 1万+
文章目录 什么是集合? Collection的基本使用 接口实现类 Collections工具类 Map接口及其实现类 Map是不是集合? 什么是集合? 集合是指具有某种特定性质的具体的或抽象的对象汇总而成的集体，有时集合也称之为容器，java中在util包...
Java 集合分页
暗武逢天的博客
03-08 5370
java实现集合分页
Java集合详解
qq_45687780的博客
04-25 2万+
基于java从入门到项目实战材料学习+个人理解总结！
java 集合
04-07
本文将深入探讨Java集合框架的基础知识，包括接口、类、以及它们在实际开发中的应用。 首先，Java集合框架由一系列接口和实现这些接口的类组成。主要的接口有`List`、`Set`和`Queue`，它们各自代表了不同特性的数据...
Java集合概述与实例分析
10-26
Java集合框架是Java编程语言中的一个核心特性，它提供了一种高效、灵活的方式来存储和操作对象数组。在Java中，集合被分为两个主要接口：Collection和Map。本篇将深入探讨Collection接口及其子接口，包括List和Set，...
实验05 Java集合.doc
06-27
Java集合框架是Java编程语言中一个非常重要的组成部分，它提供了一组高级的数据结构，使得开发者能够更方便地管理和操作对象。在本次实验中，我们主要关注了三个主要的集合接口：Set、List和Map，以及它们的一些常见...
配置Java开发环境
最新发布
Broken_x的博客
07-10 1067
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 274
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1762
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1178
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 349
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值