容器|集合
容器|集合 : 存储多个数据
数组 : 存储多个数据
一段连续的内存空间
数组的特点:
1.引用数据类型
2.定长,长度一旦确定不可改变
3.存储数据的类型相同
4.有序,有索引
集合:
存储任意引用类型数据
集合的长度可变,可以根据需求动态的增删数据,长度随之改变
public class Class001_Container {
public static void main(String[] args) {
//容器对象
ArrayList list = new ArrayList();
//存储数据
list.add("nihao");
list.add(123);
list.add(false);
System.out.println(list);
System.out.println(list.size());
//删除数据
list.remove(0);
System.out.println(list);
System.out.println(list.size());
//修改数据
list.set(1,true);
System.out.println(list);
}
}
Collection容器
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
/*
容器中的接口层次结构
Collection : 单个值的集合
Set 无序不可重复
List 有序可重复,有索引
Map : 键值对的集合(KEY-VALUE)
Collection 集合层次结构中的根接口。 集合表示一组对象,称为其元素 。
常用方法
遍历方式
foreach
iterator迭代器
*/
public class Class001_Collection {
public static void main(String[] args) {
//1.创建集合对象
Collection collection = new ArrayList();
Collection col = new ArrayList();
//2)常用方法
//boolean add(E e) 确保此集合包含指定的元素(可选操作)。
collection.add(123);
collection.add(false);
collection.add("你好");
collection.add('a');
collection.add(null);
collection.add(1.234);
col.add("aaa");
col.add("bbb");
System.out.println(col.add("ccc"));
System.out.println(collection);
System.out.println(col);
//boolean addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合中(可选操作)。
collection.addAll(col);
System.out.println(collection);
System.out.println(col);
//void clear() 从此集合中删除所有元素(可选操作)。
//col.clear();
//boolean isEmpty() 如果此集合不包含任何元素,则返回 true 。
//System.out.println(col.isEmpty());
//boolean contains(Object o) 如果此collection包含指定的元素,则返回 true 。
System.out.println(collection.contains("你好"));
//boolean containsAll(Collection<?> c) 如果此集合包含指定集合中的所有元素,则返回 true 。
System.out.println(collection.containsAll(col));
//boolean remove(Object o) 从此集合中移除指定元素的单个实例(如果存在)(可选操作)。
System.out.println(collection.remove(123));
System.out.println(collection);
//boolean removeAll(Collection<?> c) 删除此集合的所有元素,这些元素也包含在指定的集合中(可选操作)。
//boolean retainAll(Collection<?> c) 仅保留此集合中包含在指定集合中的元素(可选操作)。
col.add("ddd");
System.out.println(collection);
System.out.println(col);
//System.out.println(collection.retainAll(col));
System.out.println(collection);
//int size() 返回此集合中的元素数。
//Object[] toArray() 返回包含此集合中所有元素的数组。
//System.out.println(Arrays.toString(collection.toArray()));
System.out.println("-----------foreach----------------");
for(Object obj:collection){
System.out.println(obj);
}
System.out.println("------------iterator迭代器-------------");
//1)获取迭代器实例,用来遍历指定的集合
//Iterator<E> iterator() 返回此集合中元素的迭代器。
Iterator it = collection.iterator();
//2)判断是否存在下一个数据
while(it.hasNext()){
//3)获取下一个数据
System.out.println(it.next());
}
}
}
泛型
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
泛型: jdk1.5
参数化类型 : 数据类型作为参数传递
只能配置引用数据类型
<>定义泛型
泛型的行为发生在编译期间,运行期间发型配置的所有内容无效,泛型擦除
要求先定义泛型,才能使用泛型
泛型类 : 类型的后面定义泛型,在使用类型的时候可以通过泛型传递具体的类型,类中可以进行使用
泛型方法
泛型的优点:
代码简单简洁
增强程序健壮性,避免类型转换异常的出现
增强稳定性与可读性
*/
public class Class002_Type {
public static void main(String[] args) {
Collection<String> col = new ArrayList<>();
col.add("abc");
col.add("bcd");
col.add("dce");
for(String str:col){
}
Iterator<String> it = col.iterator();
while(it.hasNext()){
String s = it.next();
}
}
}
List集合
import java.util.ArrayList;
import java.util.List;
/*
List : 有序,可重复
Set : 无序,不可重复|唯一的
List : 有序集合(也称为序列 )。 该接口的用户可以精确控制列表中每个元素的插入位置。
新增: 一些列根据索引操作的方法
遍历方式 :
for普通for循环
foreach 增强for循环
iterator迭代器
*/
public class Class001_List {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
//添加
list.add(3);
list.add(2);
list.add(1);
System.out.println(list);
//void add(int index, E element) 将指定元素插入此列表中的指定位置(可选操作)。 --只能添加不能修改
//boolean add(E e) 将指定的元素追加到此列表的末尾(可选操作)。
list.add(3,6);
list.add(4,2);
System.out.println(list);
list.add(2,100);
System.out.println(list);
//E set(int index, E element) 用指定的元素替换此列表中指定位置的元素(可选操作)。 --只能修改不能添加
System.out.println(list.set(2,10));
System.out.println(list);
//boolean addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到指定位置的此列表中(可选操作)。
//E get(int index) 返回此列表中指定位置的元素。
System.out.println(list.get(2));
//int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引,如果此列表不包含该元素,则返回-1。
System.out.println(list.indexOf(2));
//int lastIndexOf(Object o) 返回此列表中指定元素最后一次出现的索引,如果此列表不包含该元素,则返回-1。
System.out.println(list.lastIndexOf(2));
//static <E> List<E> of(E... elements) 返回包含任意数量元素的不可修改列表。
List<String> list2 = List.of("aaa","bbb","ccc");
System.out.println(list2);
//list2.set(1,"eee"); //java.lang.UnsupportedOperationException
System.out.println(list2.get(1));
//E remove(int index) 删除此列表中指定位置的元素(可选操作)。 -->优先识别
//boolean remove(Object o) 从该列表中删除指定元素的第一个匹配项(如果存在)(可选操作)。
System.out.println(list.remove(3));
System.out.println(list);
//List<E> subList(int fromIndex, int toIndex) 返回指定的 fromIndex (包含)和 toIndex (不包括)之间的此列表部分的视图。
System.out.println(list.subList(1,3));;
System.out.println("------------------ for普通for循环-----------------");
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
}
ArrayList集合
import java.util.ArrayList;
/*
有序,可重复的
ArrayList : 实现所有可选列表操作,并允许所有元素,包括null 。
底层结构: 数组 Object[] elementData;
特点: 根据索引查询遍历效率较高,增删效率低
应用场景: 适合应用在大量做查询,少量做增删的位置
扩容问题:
初始容量 : 默认初始容量为10 ,在第一次添加add的时候进行构建 private static final int DEFAULT_CAPACITY = 10;
扩容机制 : 每次扩容原容量的1.5倍 int newCapacity = oldCapacity + (oldCapacity >> 1);
新增功能: void forEach(Consumer<? super E> action)
遍历 :
普通for
增强for
iterator迭代器
listIterator迭代器
Vector :
底层结构 : 数组
特点 : 与ArrayList相同
区别:
1) Vector是同步的|线程安全
ArrayList不同步|线程不安全,相对效率较高
2) Vector每次扩容原容量的2倍
ArrayList每次扩容原容量的1.5倍,相对ArrayList更有利于节省内存
总结 : 如果不需要线程安全实现,建议使用ArrayList代替Ve.1
定义一个ArrayList存储javabean类型的数据,测试使用
如果存储javabean类型的数据,在调用一些方法时候(indexOf..),默认调用equals方法进行判断,要求对javabean类型重写equals方法
*/
public class Class003_ArrayList {
public static void main(String[] args) {
ArrayList<Double> list = new ArrayList();
list.add(1.1);
list.add(2.2);
list.add(3.3);
list.add(null);
list.add(null);
System.out.println(list);
//遍历集合中的每一个数据,输出打印
list.forEach(System.out::println);
}
}
LinkedList集合
import java.util.LinkedList;
import java.util.Objects;
/*
LinkedList: 实现所有可选列表操作,并允许所有元素(包括null )。
底层结构: 双向链表
特点: 查询效率低,增删效率高
应用场景:单个数据值的集合中,允许数据有序,且可重复,在大量做增删,销量做查询的时候时候适合使用链表
新增功能: 新增了一些与链表头尾相关的方法
注意: 请注意,此实现不同步。
定义链表结构,存储javabean类型的数据,测试使用,遍历使用
存储javabean类型数据时候,要求javabean类型重写equals方法,否则使用一些判断比较的方法时候回默认调用equals方法
*/
public class Class004_LinkedList {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList();
list.add("bbb");
list.add("ccc");
list.add("ddd");
System.out.println(list);
list.addFirst("aaa");
list.addLast("ddd");
list.addLast(null);
System.out.println(list);
LinkedList<Person> persons = new LinkedList();
persons.add(new Person("zhangsan",18));
persons.add(new Person("lisi",17));
persons.add(new Person("wangwu",19));
System.out.println(persons);
System.out.println(persons.contains(new Person("zhangsan",18)));
}
}
class Person{
private String name;
private int age;
public Person() {
}
public Person(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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
/*@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}*/
}
手写LinkedList基本功能
import java.util.LinkedList;
//通过单向链表手写LinkedList : 了解
public class Class005_MyLinked {
public static void main(String[] args) {
MyLinkedList my = new MyLinkedList();
my.add("nihao");
System.out.println(my.size());
System.out.println(my);
my.add("1111");
System.out.println(my);
System.out.println(my.size());
System.out.println(my.get(0));
System.out.println(my.get(1));
System.out.println(my);
LinkedList list = new LinkedList();
list.add("aaa");
list.add("vvv");
System.out.println(list);
}
}
class MyLinkedList{
//记录链表头节点
private Node head;
//数据的个数
private int size;
public MyLinkedList() {
}
//获取
public Object get(int index){
//校验索引
if(index<0 || index>=size){
throw new IndexOutOfBoundsException(index+"越界...");
}
//用作遍历链表使用
Node temp = head;
//遍历链表
for(int i=0;i<size;i++){ //i作为索引存在
if(i==index){
return temp.getData();
}
temp= temp.getNext();
}
return null;
}
/**
* 添加数据
* @param value 要添加的数据
*/
public void add(String value) {
//创建新节点
Node newNode = new Node(value,null);
//判断原链表中是否存在节点
if(head==null && size==0){
//不存在节点,新节点就作为链表头节点
head = newNode;
//长度+1
size++;
return;
}
//temp 指向每一个节点,用来遍历
Node temp = head;
//存储节点,遍历原链表,找到最后一个节点
while(temp.getNext()!=null){
temp = temp.getNext();
}
//新节点挂上去
temp.setNext(newNode);
//长度+1
size++;
}
//size
public int size(){
return this.size;
}
//重写toString,把链表中的每一个节点的数据获拼接一个字符串返回
@Override
public String toString() {
//链表中不存在数据,直接返回[]
if(size==0){
return "[]";
}
//链表中存在数据
Node temp = head;
//sb做字符串的拼接
StringBuilder sb = new StringBuilder("[");
//遍历链表,获取到每一个节点的数据值,拼接完成字符串返回
while(true){
sb.append(temp.getData()).append(", ");
//没有下一个节点,循环结束
if(temp.getNext()==null){
break;
}
//存在下一个节点,temp指向下一个节点
temp= temp.getNext();
}
//去除最后多余的", "
sb.delete(sb.length()-2,sb.length());
return sb.append("]").toString();
}
}
//节点
class Node{
private Object data;
private Node next;
public Node(Object data, Node next) {
this.data = data;
this.next = next;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", next=" + next +
'}';
}
}