集合的基本内容

瑟瑟发抖的萌新学徒

已于 2023-01-13 22:59:27 修改

阅读量67

点赞数

文章标签： java jvm 开发语言

于 2023-01-09 22:11:19 首次发布

本文链接：https://blog.csdn.net/m0_56420338/article/details/128570690

版权

集合的由来以及集合的家主（继承体系）

1、集合的由来

数组长度固定，当需要正价或减少元素时，数组需要重新定义，java内部提供了集合类，能存储任意对象，长度可以改变随着元素的增加或减少发生变化。

2、数组和集合的区别

1.数组可以存储基本数据类型，也可以存储可以类型。

集合只能存储应用数据类型（对象）

2.数组长度是固定的，不可自增或自减

集合长度可变，可以根据元素增长而变化。

3、什么时候使用

1.如果元素个数固定，用数组。

2.如果元素个数不固定，拥集合。

4、集合框架Collection集合的基本功能测试

boolean add（E e）；添加

boolean remove（Object obj）；删除

boolean clear（）；清空

boolean contains（Object o）；比较

boolean isEmpty（）；判断是否有内容

int size（）；元素数

注意：CollectionXxx.java使用了未经检查或不安全的操作

要了解详细信息，使用——Xlint；unchecked重新编译

java编译器任务该程序存在安全隐患（这不是编译失败，可以不要理会）

5、Collection集合中带ALl功能

addAll 添加所有

removeAll 删除所有

containsAll 比较所有

retainAll

package com.demo.cn;

import java.util.ArrayList;
import java.util.Collection;

public class Demo7 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Collection c=new ArrayList<>();
		c.add("abc");
		c.add(true);
		c.add(100);
		
		Collection c2=new ArrayList<>();
		c2.add(99);
		c2.add(100);
		System.out.println(c.retainAll(c2));//去c和c2的交集，如果没有c会被清空
		System.out.println(c);
		System.out.println(c2);
	}

}

6、集合的遍历之迭代器（interator）

迭代器：集合是用来存储元素的，存储的元素需要查看，那就需要迭代器来迭代。

hasNext（）；判断是否有元素，有为true；

next（）；提取元素

向下转型


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Collection coll=new ArrayList<>();
		coll.add(new Student("张三",23));
		coll.add(new Student("李四",24));
		coll.add(new Student("王五",25));
		
		Iterator it=coll.iterator();//判断迭代器是否有元素，有返回true
		while(it.hasNext()) {
			
			Student s=(Student) it.next();
			System.out.println(s.getName()+"   "+s.getAge());
		}
		
	}

}

7、List集合特有的功能和概述

void add（int index，E element）；指定下标位置添加内容

E removt（int index）；指定下标位置删除

E get（int index）；指定下标位置查看

E set（int index，E element）；指定下标位置修改

list集合是通过下标删除（remove）Integer i=111；也可以通过i删除。

ListIterator可以在遍历过程中添加内容

ListIterator中方法

biilean hasNext（）；是否有下一个；

biilean hasPrevious（）；是否有前一个；

Object next（）；返回下一个元素；

Object Previous（）；返回上一个元素；

Vector细节

vector和arrayList底层都是数组

Vertor是线程安全（因为同步）

arrayLIst是线程不安全的

Vector特有功能

public void addElement（E obj）；在末尾添加元素大小加1；

public E elementAt（int index）；返回指定索引处组件

public Enumeration element（）；返回此向量主键的枚举

Vector

package com.demo.cm;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Vector;

public class Demo4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//Vector集合，线程安全
	Vector v=new Vector();
	v.addElement("a");
	v.addElement("b");
	v.addElement("c");
	v.addElement("d");
	//迭代
	Enumeration en=v.elements();//获取枚举
	while(en.hasMoreElements()) {//判断集合中是否含有元素
		System.out.println(en.nextElement());//获取集合中元素
		
	}
	}

}

无法对遍历中的元素进行更改

数组结构之数组和链表

数组：查询快，修改快

链表：查询慢，修改慢，增加快删除快

LIst的三个子类的特点：（面试题）

ArrayList：底层是数组结构，查询快，修改快，增加慢，删除慢，线程不安全，效率低

Vector：底层是数组结构，查询快，修改快，增加慢，删除慢，线程安全，效率略低。

Vector相对ArrayList查询慢，因为Vector线程安全。

Vector相对LinkedList增删慢（数组结构）

LinkdeList：底层是链表结构，查询慢，修改慢，增加快，删除快，线程不安全，效率高。

Vector和ArrayList的区别：

Vertor是线程安全，效率低

ArrayList是线程不安全，效率高。

ArrayList和LinkedList的区别：

ArrayList底层是数组结构，查询、修改快。

LinkedList底层是链表结构，删除、添加快。

查询多：ArrayList

增删多：LinkedList

如果都多：ArrayLIst

Vector只有在面试的时候使用，

ArrayLIst中重复字符串去除

remove和contains底层都是equls

package com.demo1.cn;

import java.util.ArrayList;
import java.util.Iterator;

public class Demo1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList a=new ArrayList();
		a.add(new Student("张三",23));
		a.add(new Student("张三",23));
		a.add(new Student("李四",24));
		a.add(new Student("李四",24));
		a.add(new Student("王五",25));
		System.out.println(a);
		ArrayList newa=getString(a);
		System.out.println(newa);
		
	}

	private static ArrayList getString(ArrayList a) {
		// TODO Auto-generated method stub
		//1创建一个新集合
		ArrayList newa=new ArrayList();
		//2.获取迭代器
		Iterator it=a.iterator();
		//3.判断集合中是否有元素
		while(it.hasNext()) {
			//将每一个元素临时记录
			Object obj=it.next();
			if(!newa.contains(obj)) {
				newa.add(obj);
			}
		}
		return newa;
	}

}



package com.demo1.cn;

import java.util.Objects;

public class Student{
	private String name;
	private int age;
	public Student(String name,int age){
		this.name=name;
		this.age=age;
	}
	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;
	}
	//重写equals底层
	@Override
	public boolean equals(Object obj) {
		Student s=(Student)obj;
		return this.name.equals(s.name)&&this.age==s.age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
		

}

LinkedLIst的特有功能

public void addFirst（E e）以及addLast（E e）添加第一个或最后一个元素。

public E getFIrst（）以及getLAst（）；获取第一个或最后一个元素。

public E removeFirst（）以及removeLast（）；删除第一个元素或删除最后一个元素。被删除的元素会返回。

public void get（int index）；获取下标（底层运算）。

栈和队列数据结构

栈：先进后出

队列：先进先出

底层封装：先进后出

package com.demo1.cn;

import java.util.LinkedList;

public class Stack {
private LinkedList list=new LinkedList();

//模拟进栈
public void in(Object obj) {
	list.add(obj);
}
//模拟出栈
public Object out() {
	return list.removeLast();
}
//判断是否为空
public  boolean isEmpty() {
	return list.isEmpty();
}
}

package com.demo1.cn;

public class Demo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Stack s=new Stack();
		s.in("a");
		s.in("b");
		s.in("c");
		s.in("d");
		s.in("a");
		s.in("b");
		while(!s.isEmpty()) {
			System.out.println(s.out());
		}
	}

}