（一）集合
-
概念：对象的容器，定义了对多个对象进行操作的常用方法，类似数组的功能
-
特点：长度不固定，只能存储引用类型
-
位置：Java.util.*
（二）Collection接口
-
特点：代表一组任意类型的对象，无序、无下标、不能重复
-
方法：
- boolean add(Odject obj) —— 添加一个对象
- boolean addAll(Collection c) —— 将一个集合中的所有对象添加到此集合中
- void clear() —— 清空此集合中的所有对象
- boolean contains(Odject o) —— 检测此集合中是否包含o对象
- boolean equals(Odject o) —— 比较此集合是否与指定对象相等
- boolean isEmpty() —— 判断此集合是否为空
- boolean remove(Odject o) —— 在此集合中移除o对象
- int size() —— 返回此集合中的元素个数
- Object[] toArray() —— 将此集合转换成数组
Collection使用
import java.util.*;
public class Demo01 {
public static void main(String[] args) {
//创建集合
Collection collection= new ArrayList();
//1.添加元素
collection.add("苹果");
collection.add("橘子");
collection.add("榴莲");
System.out.println("元素个数："+collection.size());
System.out.println(collection);
//2.删除元素
collection.remove("榴莲");
System.out.println("删除之后："+collection.size());
//3.遍历元素
//使用增强for循环
System.out.println("使用增强for循环");
for (Object object:collection){
System.out.println(object);
}
//使用迭代器
System.out.println("使用迭代器");
//hasNext(); ————有没有下一个元素
//next(); ————获取下一个元素
//remove(); ————删除当前元素
Iterator it= collection.iterator();
while(it.hasNext()){
String s=(String)it.next();
System.out.println(s);
}
//4.判断
System.out.println(collection.contains("橘子"));
System.out.println(collection.isEmpty());
}
}（三）List接口
-
特点：有序、有下标、元素可以重复
-
方法：
- 有Collection中的所有方法
- void add(int index,Object o) —— 在index位置插入对象o
- boolean addAll(int index,Collection c) —— 将一个集合中的元素添加到此集合中的index位置
- Object get(int index) —— 返回集合中指定位置的元素
- List subList(int formIndex,int toIndex) —— 返回 formIndex和 toIndex之间的集合元素
List使用
-
遍历元素
//使用 ListIterator迭代器
//和Iterator的区别：ListIterator可以向前或向后遍历，添加、删除、修改元素
ListIterator listIterator=list.listIterator();
System.out.println("使用列表迭代器从前往后");
while (listIterator.hasNext()){
System.out.println(listIterator.nextIndex()+","+listIterator.next());
}
System.out.println("使用列表迭代器从后往前");
while (listIterator.hasPrevious()){
System.out.println(listIterator.previousIndex()+","+listIterator.previous());
}-
获取位置
System.out.println(list.indexOf("黄瓜"));List实现类
ArrayList
-
数组结构实现，查询快、增删慢，必须开辟连续的存储空间
-
JDK1.2版本，运行效率快、线程不安全
//创建集合
ArrayList arrayList=new ArrayList<>();
//遍历
ListIterator list=arrayList.listIterator();
System.out.println("使用列表迭代器从前往后");
while (list.hasNext()){
System.out.println(list.nextIndex()+","+list.next());
}
System.out.println("使用列表迭代器从后往前");
while (list.hasPrevious()){
System.out.println(list.previousIndex()+","+list.previous());
}Vector
-
数组结构实现，查询快、增删慢
-
JDK1.0版本，运行效率慢、线程安全
public class Demo04 {
public static void main(String[] args) {
Vector vector = new Vector();
vector.add("abc");
vector.add("def");
vector.add("ghi");
//使用枚举器遍历
Enumeration en=vector.elements();
while (en.hasMoreElements()){
String s=(String)en.nextElement();
System.out.println(s);
}
}
}LinkedList
-
链表结构实现，增删快、查询慢，无需开辟连续的存储空间
（四）泛型
-
JDK1.5新特性，本质是参数化类型，把类型作为参数传递
-
形式：泛型类、泛型接口、泛型方法
-
语法：<T,....> T称为类型占位符，表示一种引用类型，编写多个时用逗号隔开
-
好处：
-
提高代码的重用性
-
防止类型转换异常，提高代码的安全性
-
泛型类
语法：类名<T,...>
使用泛型类创建对象
注意：1、泛型只能使用引用类型
2、不同泛型类型对象之间不能相互赋值
public class MyGeneric<T> {
//使用泛型 T
//创建变量
T t;
//泛型作为方法的参数
public void show (T t){
System.out.println("泛型类："+t);
}
//泛型作为方法的返回值
public T getT(){
return t;
}
}泛型接口
语法：接口名<T,...>
public interface MyInterface<T> {
String name="Joyce_yu";
T serve(T t);
}public class MyInterfaceImpl1 implements MyInterface<String>{
@Override
public String serve(String t) {
//TODO AUTO-generated method stub
System.out.println("泛型接口1："+t);
return t;
}
}public class MyInterfaceImpl2<T> implements MyInterface<T>{
@Override
public T serve(T t) {
System.out.println("泛型接口2："+t);
return t;
}
}泛型方法
语法：<T,...>返回值类型
public class MyGenericMethod {
public <T> T show(T t){
System.out.println("泛型方法："+t);
return t;
}
}运行测试
public class TestGeneric {
public static void main(String[] args) {
MyGeneric<String>myGeneric1=new MyGeneric<String>();
myGeneric1.t="hello";
myGeneric1.show("hello,everyone!");
String string=myGeneric1.getT();
MyGeneric<Integer>myGeneric2=new MyGeneric<Integer>();
myGeneric2.t=100;
myGeneric2.show(200);
Integer integer=myGeneric2.getT();
//泛型接口
MyInterfaceImpl1 impl1=new MyInterfaceImpl1();
impl1.serve("Joyce_yu");
MyInterfaceImpl2 impl2=new MyInterfaceImpl2();
impl2.serve(1000);
//泛型方法
MyGenericMethod myGenericMethod=new MyGenericMethod();
myGenericMethod.show("TFBoys");
myGenericMethod.show(520);
}
}运行结果
泛型集合
-
概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致
-
特点：
- 编译即可检查，而非运行时抛出异常
- 访问时不必类型转换（拆箱）
- 不同泛型之间引用不能相互赋值，泛型不存在多态
（五）Set接口
-
特点：无序、无下标、元素不可重复
-
方法：全部继承自Collection中的方法
HashSet
-
存储结构：哈希表（数组+链表+红黑树）
-
存储过程：
- 根据hashcode计算保存位置，如果此位置为空，则直接保存，如果不为空则执行第二步
- 执行equals方法，如果结果为true，则认为是重复，否则，形成链表补充内容
3. 补充内容
TreeSet
-
基于排列顺序实现元素不可重复
-
实现了SortedSet接口，对集合元素自动排序
-
元素对象的类型必须实现Comparable接口，指定排序规则
-
通过CompareTo方法确定是否为重复元素
import java.util.Comparator;
import java.util.TreeSet;
public class Demo05 {
public static void main(String[] args) {
//创建集合，并指定比较规则
TreeSet<String> treeSet=new TreeSet<>(new Comparator<String>(){
@Override
public int compare(String s1, String s2) {
int n1=s1.length()-s2.length();
int n2=s1.compareTo(s2);
return n1==0?n2:n1;
}
});
treeSet.add("World");
treeSet.add("China");
treeSet.add("Liaoning");
treeSet.add("Fushun");
treeSet.add("Xinbin");
treeSet.add("Shangjiahe");
treeSet.add("Wulong");
System.out.println(treeSet);
}
}（六）Map接口
-
特点：存储键值对，键不能重复、值可以重复，无序、无下标
-
方法：
- V put(K key,V value) —— 将对象存入到集合中，关联键值；key重复则覆盖原值
- Object get(Object,key) —— 根据键获取对应的值
- Set <K> —— 返回所有key
- Collection <V> values() —— 返回包含所有值的Collection集合
- Set<Map.Entry<K,V>> —— 键值匹配的Set集合
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo06 {
public static void main(String[] args) {
//创建Map集合
Map<String,String> map=new HashMap<>();
//1.添加元素
map.put("cn","中国");
map.put("uk","英国");
map.put("us","美国");
System.out.println("元素个数："+map.size());
System.out.println(map.toString());
//2.删除
map.remove("us");
System.out.println("删除之后："+map.size());
//3.遍历
//entrySet();效率高于 keySet();
//3.1使用 keySet();
Set<String> keyset=map.keySet();
for (String key:map.keySet()){
System.out.println(key+"--keySet--"+map.get(key));
}
//3.2使用 entrySet();
Set<Map.Entry<String,String>> entries=map.entrySet();
for (Map.Entry<String,String> entry:entries){
System.out.println(entry.getKey()+"--entrySet--"+entry.getValue());
}
//4.判断
System.out.println(map.containsKey("cn"));
System.out.println(map.containsValue("法国"));
}
}运行结果
HashMap
-
JDK1.2版本，线程不安全，运行效率快；允许null作为key或value
-
存储结构：哈希表（数组+链表+红黑树）
TreeMap
存储结构：红黑树
（七）Collections
package 集合框架;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Demo07 {
public static void main(String[] args) {
List<Integer> list=new ArrayList<>();
list.add(20);
list.add(5);
list.add(12);
list.add(30);
list.add(6);
//sort排序
System.out.println("排序前："+list.toString());
Collections.sort(list);
System.out.println("排序后："+list.toString());
//binarySearch二分查找
int i=Collections.binarySearch(list,13);
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(new Integer[10]);
System.out.println("设置数组大小为："+arr.length);
System.out.println("list转成数组："+Arrays.toString(arr));
//数组转成集合
String[] names={"张三","李四","王五"};
List<String> list2=Arrays.asList(names);
System.out.println("数组转成集合："+list2);
}
}运行结果
扫一扫
154
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
