编程语言
首页 > 编程语言> > Java集合框架

Java集合框架

作者:互联网

Java集合

一、定义

1、对象的容器,定义了对多个对象进行操作的常用方法,可实现数组的功能
集合所在包为:Java。util.*

2、集合和数组区别:
数组长度固定,集合长度不固定
数组可以存储基本类型和引用类型,集合只能引用类型

二、collection

体系结构

1、Collection父接口

特点:代表一组任意类型的对象,无序、无下标、不能重复
方法:
集合方法

2、collection接口使用

迭代器:
1、iterator():返回按适当顺序在列表上进行迭代的迭代器(参考以上collection接口)
listIterator():按适当顺序,返回此列表元素的列表迭代器
listIterator(int index):按适当顺序返回列表中元素的列表迭代器,从列表的指定位置开始

2、iterator是对collection进行迭代(迭代的意思就是循环或者遍历)的迭代器,有以下几个方法:
hasNext(): void如果仍有元素迭代,则返回true
next():返回迭代的下一个元素
remove():void 从迭代器指向的collection中移除迭代器返回的最后一个元素
迭代过程中只能使用这三个方法,不能使用collection方法,否则会出现并发修改异常

3、listIterator()、listIterator(int index)是列表迭代器,允许按任一方向向前或向后遍历列表、迭代器期间修改列表,并获得迭代器在列表中的当前位置,有以下几个方法:
add():将指定元素插入列表
hasNext():以正向遍历列表,如果列表迭代器有多个元素,则返回true
hasPrevious():如果逆向遍历列表,列表迭代器有多个元素,则返回true
next():返回列表中下一个元素
nextIndex():返回对next的后续调用所返回元素的索引
previous():返回列表中的前一个元素
previousIndex():返回对previous的后续调用所返回元素的索引
remove()
set(E e):用指定元素替换next或previous返回的最后一个元素

添加元素

删除元素

遍历元素

判断元素

获取元素:这是list集合有的操作

collection使用源代码:

package com.an;



import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

public class HelloWorld {
public static void main(String[] args) {
    //创建集合
    Collection collection=new ArrayList();
    //添加元素
    collection.add("苹果");
    collection.add("香蕉");
    collection.add("芭乐");
    System.out.println("元素个数为:"+collection.size());
    System.out.println(collection);
    //删除元素
    collection.remove("苹果");
    //collection.clear();这是表示删除所有元素
    System.out.println(collection);
    //遍历元素
    System.out.println("使用增强for");
    for (Object object : collection) {
        System.out.println(object);
    }
    System.out.println("使用迭代器");//使用迭代器,迭代器是用来专门遍历集合的一种方法
    Iterator it= collection.iterator();//返回类型是一个接口
    while(it.hasNext()){
        String d=(String) it.next();
        System.out.println(d);
        //collection.remove(d);这里不能用这个方法,否则会出现并发修改异常,但是可以用迭代器里的方法:it.remove()
    }
    //判断
    System.out.println(collection.contains("香蕉"));
}
}

三、List集合

1、List接口

特点:有序、有下标、元素可以重复(有下标就可以用for循环了,像collection接口没有下标就不能用for循环)

方法:
List方法

List接口也是一个有序的collection,也包含了collection里的方法

迭代器:
iterator():返回按适当顺序在列表上进行迭代的迭代器(参考以上collection接口)
listIterator():按适当顺序,返回此列表元素的列表迭代器
listIterator(int index):按适当顺序返回列表中元素的列表迭代器,从列表的指定位置开始

列表迭代器,允许按任一方向遍历列表、迭代器期间修改列表,并获得迭代器在列表中的当前位置

2、List接口使用

list使用源代码

package com.an;



import java.util.*;

public class HelloWorld {
public static void main(String[] args) {
    //创建集合对象
    List list=new ArrayList<>();
    //添加元素
    list.add("苹果");
    list.add("香蕉");
    list.add(0,"芭乐");//从下标为0处插入芭乐
    System.out.println("元素个数为:"+list.size());
    System.out.println(list);//或者System.out.println(list.toString())
    //删除元素
    list.remove("苹果");
    //collection.clear();这是表示删除所有元素
    System.out.println(list);
    //遍历元素
    //使用for遍历
    System.out.println("使用for循环");
    for(int i=0;i< list.size();i++){
        System.out.println(list.get(i));
    }
    System.out.println("使用增强for");
    for (Object object : list) {
        System.out.println(object);
    }
    System.out.println("使用迭代器");//使用迭代器,迭代器是用来专门遍历集合的一种方法
    Iterator it= list.iterator();//返回类型是一个接口
    while(it.hasNext()){
        String d=(String) it.next();
        System.out.println(d);
        //collection.remove(d);这里不能用这个方法,否则会出现并发修改异常,但是可以用迭代器里的方法:it.remove()
    }
    System.out.println("使用列表迭代器");
    ListIterator lit=list.listIterator();
    System.out.println("从前往后");
    while(lit.hasNext()){
        System.out.println(lit.nextIndex()+":"+lit.next());
    }
    System.out.println("从后往前");
    while(lit.hasPrevious()){
        System.out.println(lit.previousIndex()+":"+lit.previous());
    }
    //判断
    System.out.println(list.contains("香蕉"));
    //获取位置
    System.out.println(list.indexOf("香蕉"));
}
}

四、list实现类

ArrayList类:

数组结构实现,查询快,增删慢
有下标,可重复
JDK1.2版本 运行效率快、线程不安全

Vector类

数组结构实现,查询快、增删慢
JDK1.0版本 运行效率慢,线程安全

LinkedList类

链表结构实现,增删快、查询慢

1、ArrayList的使用

参考文章

2、Vector的使用

vector类可以实现可增长的对象数组。与数组一样,它包含可以使用整数索引进行访问的组件。但是,它的大小可以根据需要增大或者缩小,以适应创建vector后进行添加或溢出项的操作

3、LinkList的使用

存储结构:双向链表

LinkList和ArrayList的区别

ArrayList:必须开辟连续空间,查询快,增删慢
LinkedList:无需开辟连续空间,查询慢,增删快

五、泛型

本质是参数化类型,把类型作为参数传递
常见形式:泛型类、泛型接口、泛型方法
语法:<T,...> T称为类型占位符,表示一种引用类型
好处:提高代码的重用性
防止类型转换异常,提高代码安全性

1、泛型类

语法:类名<T,...>

package com.an;
public class HelloWorld<T> {

    //使用泛型类
    //创建变量
    T t;
//添加方法,使用泛型作为方法参数
public void show(T t){
    System.out.println(t);
}
//泛型作为方法的返回值
public T getT(){
    return t;
}
}







package com.an;
public class TestHelloWorld {
public static void main(String[] args) {
    //使用泛型类创建对象,创建的对象为String类型
    HelloWorld<String> helloWorld= new HelloWorld<String>();
    helloWorld.t="hello";
    helloWorld.show("大家好");
    String string= helloWorld.getT();
}
}

如果在运行是出现遇见javafx.application.Application错误,有可能是运行时选择的启动类不对,选择带有main方法的启动类
错误

2、泛型接口

语法:接口名

接口:

package com.an;
public interface MyInterface<T> {
String name="张三";
T server(T t);//创建一个server方法
}

接口实现类:(要重写接口中的方法)

package com.an;
public class MyInterfaceImp implements MyInterface<String>{
@Override
public String server( String t) {
    System.out.println(t);
    return t;
}
}





package com.an;
public class TestHelloWorld {
public static void main(String[] args) {
    
    MyInterfaceImp imp = new MyInterfaceImp();
    System.out.println("w");

}
}

3、泛型方法

语法: 返回值类型

定义泛型方法
package com.an;

public class Method {
public <T> T show(T t){
    System.out.println("泛型方法"+t);
    return t;
}
}



package com.an;



public class TestHelloWorld {
public static void main(String[] args) {
    //泛型方法
    Method method = new Method();
    method.show("大家好");
}


    }

4、泛型集合

参考文章

六、set集合

特点:无序、五下标、元素不可重复
方法:全部继承collection方法

1、set接口使用

package com.an;


import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class TestHelloWorld {
public static void main(String[] args) {
    //创建集合
    Set<String> set=new HashSet<String>();
    //添加数据
    set.add("苹果");
    set.add("华为");
    set.add("小米");
    System.out.println("数据个数:"+set.size());
    System.out.println(set.toString());
    //删除数据
    set.remove("苹果");
    System.out.println(set.toString());
    //遍历数据
    System.out.println("增强for循环");
    for (String string : set) {
        System.out.println(string);
    }
    System.out.println("使用迭代器");
    Iterator<String> it=set.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
    //判断
    System.out.println(set.contains("华为"));
    System.out.println(set.isEmpty());
}


}

七、set实现类

1、HashSet:

基于HashCode计算元素存放位置
当存入元素的哈希码相同时,会调用equals进行确认,如结果为true,则拒绝后者存入
存储结构:哈希表(数组+链表+红黑树)(参考下数据结构里的散列函数)

package com.an;


import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class TestHelloWorld {
public static void main(String[] args) {
    //创建集合
    HashSet<String> hashSet=new HashSet<String>();
    //添加数据
    hashSet.add("苹果");
    hashSet.add("华为");
    hashSet.add("小米");
    System.out.println("数据个数:"+hashSet.size());
    System.out.println(hashSet.toString());
    //删除数据
    hashSet.remove("苹果");
    System.out.println(hashSet.toString());
    //遍历数据
    System.out.println("增强for循环");
    for (String string : hashSet) {
        System.out.println(string);
    }
    System.out.println("使用迭代器");
    Iterator<String> it=hashSet.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
    //判断
    System.out.println(hashSet.contains("华为"));
    System.out.println(hashSet.isEmpty());
}


}

2、HashSet存储方式

第一步:根据HashCode计算存储的位置,如果位置为空,则直接保存,如果不为空执行第二步
第二步:再执行equals方法,如果equals方法为true,则认为是重复,否则形成链表

八、TreeSet(红黑树)

基于排列顺序实现元素不重复
实现了SortedSet接口,对集合元素自动排序
元素对象的类型必须实现Comparable接口,指定排序规则
同过compareTo方法确定是否为重复元素

1、TreeSet使用

存储结构:红黑树
使用treeset保存数据,要求元素必须实现Comparable接口,否则会出现ClassCastException异常
CompareTo方法

treeset使用

treeset使用2

2、Comparator接口使用

comparator迭代器
有迭代器就不需要用25行后面的代码了

九、Map集合

Map

Map父接口:
Map父接口

1、Map使用

Map1
Map2
Map3

2、HashMap使用

线程不安全,运行效率快,允许用null作为key或者value
存储结构:哈希表(数组+链表+红黑树)
使用key计算出来的HashCode和equals一样可作为重复
HashMap

key不可以重复,如果重复的化,会覆盖原来的值,value可以重复
HashMap1

3、Hashtable

线程安全,运行效率慢,不允许null作为key或者value
properties是是Hashtable的子类,要求keyhe1value都是string,通常用于配置文件的读取

4、treeMap

实现了SortedMap接口(是Map的子接口),可以对key自动排序
存储结构:红黑树
treeMap

treeMap0
treeMap1
treeMap2

十、collection工具类

collection工具类

package com.an;


import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) {
    //创建集合
    List<Integer> list = new ArrayList<>();
    //添加数据
    list.add(1);
    list.add(3);
    list.add(2);
    System.out.println("数据个数:" + list.size());
    System.out.println(list.toString());
    //排序
    Collections.sort(list);
    System.out.println(list.toString());
    //binarysearch二分法检索
    int i = Collections.binarySearch(list, 3);
    System.out.println(i);
    //copy复制
    List<Integer> dest = new ArrayList<>();
    for (int k = 0; k < list.size(); k++) {
        dest.add(0);
    }
    Collections.copy(dest, list);
    System.out.println(dest.toString());
    //reverse反转
    Collections.reverse(list);
    System.out.println(list);
    //shuffle打乱
    Collections.shuffle(list);
    System.out.println(list);
    //list转成数组
    Integer[] arr = list.toArray(list.toArray(new Integer[0]));
    System.out.println(Arrays.toString(arr));
    //数组转成集合,这里的集合是一个受限集合,不能添加和删除
    String[] name = {"一", "二", "三"};
    List<String> list1 = Arrays.asList(name);
    System.out.println(list1);
    //把基本类型数组转为集合时,需要修改为包装类型
    Integer[] num = {1, 2, 3, 4};
    List<Integer> s = Arrays.asList(num);
    System.out.println(s);
    }


}

十、总结

集合总结

标签:Java,迭代,框架,list,System,collection,println,集合,out
来源: https://www.cnblogs.com/ChenAiNan/p/16608351.html