泛型
为什么需要泛型
早期的Object类型可以接收任意的对象类型 但在实际使用中 会有类型转换的问题 存在隐患 所以
提供泛型解决这一问题
泛型:类型参数化 或者参数化类型 将类型作为参数传入
<任意的大写字母 可以有多个>
泛型的传入类型只能是 类类型
public class TypeDemo {
public static void main(String[] args) {
//没有定义类型 默认是Object
ArrayList list=new ArrayList();
list.add("a");
list.add(1);
list.add(false);
for (int i = 0; i < list.size() ; i++) {
//再具体使用时要向下转型
Object obj=list.get(i);
if (obj instanceof String){
String s=(String) obj;
}
if (obj instanceof Integer){
Integer s=(Integer) obj;
}
if (obj instanceof Boolean){
Boolean s=(Boolean) obj;
}
}
public class TypeDemo <T,E>{
T name;
E age;
public T test(E e){
return null;
}
public static void main(String[] args) {
TypeDemo<String,Integer> t=new TypeDemo<>();
t.test(2);
}
}集合的概念
集合 是一种容器
数组也是一个容器 但是长度一经定义不可改变并且只能存储同一种类型的数据
java为什么要提供许多的集合类在存储数据?
1.集合类的长度是可以改变的
2.不同的数据存储 操作方式不同
集合体系的概述
Collection 单列集合
List 可重复
ArrayList 底层数组实现的 查询快 增删慢 当数组扩容后没填满 空间浪费
创建之初 在底层创建一个默认的数组 当数组内容满了之后 继续添加时会扩容
LinkedList 底层是链表实现的 查询慢 增删块
查找时从第一个向后查找
增加删除元素是其他元素位置不动 只改变指针域的值
Vector:底层是数组实现 线程安全
ArrayList与LinkedList的区别
ArrayList：查找元素时候可以直接通过元素的下标进行索引，检索速度快。
若要在第i个位置插入元素时需要先找到第i个元素的位置，再将第i+1个元素及以后的元素全部向后移动一位，在插入第i个位置。
若要删除第i个位置上的元素，需要先找到的i个位置，删除该位置上的元素，在将第i+1位及以后的所有元素都向前移动一位。
因此对于ArrayList来说，
插入和删除元素的效率不如LikedList快。
LinkedList：在增删改较多的情况下使用LinkedList
LinkedList的底层实现是链表，链表有头结点，数据域和指针域三部分组成。
在插入元素时，只需要找到指定位置，将该位置元素的头指针与上一个元素断开，将该要插入的元素的头结点链接到上一个元素的尾结点处，
在将要插入的元素的尾结点链接到第i个元素的头结点上即可。对于删除操作是相反的，先断开第i个元素的头指针与尾指针，
在将i+1个位置上的元素与第i个位置上的元素链在一起即可。用LinkedList减少了元素前后移动所需耗费的时间。对于查找操作，
需要根据一定的算法从前向后或者从后向前进行遍历，速度较慢。
public class ArrayListDemo1 {
/*
List接口特点
可以存储相同元素
有序的 按照元素的插入顺序排列
ArrayList 底层数组实现的 查询快 增删慢 当数组扩容后没填满 空间浪费
创建之初 在底层创建一个默认的数组 当数组内容满了之后 继续添加时会扩容
LinkedList 底层是链表实现的 查询慢 增删块
查找时从第一个向后查找
增加删除元素是其他元素位置不动 只改变指针域的值
Vector
*/
public static void main(String[] args) {
ArrayList list=new ArrayList();
/*
调用默认无参的构造方法创建对象时并没有实际创建数组 第一次添加元素时创建 默认长度为10
*/
ArrayList list1=new ArrayList(10);
/*
调用有参的构造方法 创建ArrayList对象时 创建一个指定长度的数组 this.elementDate=new Object[initialCapacity];
*/
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
list.add("g");
list.add("d");
list.add("i");
list.add("j");
list.add("k");//当数组满了之后 会自动扩容 容量为之前的1.5倍
//list.remove(2);删除索引位置2的元素
//System.out.println( list.remove("a"));//有a的话删除 返回true
//list.isEmpty();//判断是否为空
list.add(3,"a");//向指定位置添加元素
//list.clear();//清空
//System.out.println(list.get(2));//得到指定位置的元素
System.out.println(list.indexOf("d"));//得到指定元素 的位置
// System.out.println(list.lastIndexOf("a"));
//System.out.println(list.set(4,"a"));//将指定位置元素修改为指定元素
// List l= list.subList(3,6);//截取3-6位置的元素
//System.out.println(l);
System.out.println(list);
}Set 不可重复
HashSet 底层是hash表实现
package com.ff.javacollection.day1.day5;
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
/*
set不能存储重复元素
HashSet 无序存储(这里的无序指的是 添加元素的顺序)
HashSet的底层是HashMap
HashSet只是使用了HashMap的键的那一列
是从HashMap扩展出来的一格单列存储的类
第一次添加元素时 会在底层创建一个长度为16 的哈希表
用内容的hash值 计算此元素在hash表中的位置
HashMap的底层 链表+红黑树
当链表长度大于8 链表转为红黑树
hash表默认长度为16 当容量添加为长度的0.75时 会自动扩容 扩容为原来的两倍
*/
HashSet set=new HashSet();
set.add("a");
set.add("i");
set.add("c");
set.add("p");
set.add("z");
set.add("重地");//通话 重地 hash值相同 内容不同
set.add("通话");
/*
1.哈希结构底层是如何存储数据的
哈希表:本质也是数组
2.HashSet是如何去除重复元素的
先用元素的hash值比较(速度快) 但是内容不同 hash值也可能一样
hash相同时 在使用 equals方法 判断内容是否相同(安全可靠 效率低)
*/
System.out.println(set);
}
}TreeSet 底层是红黑树实现
public class TreeSetDemo3 {
public static void main(String[] args) {
/*
Set 不能存储重复元素
TreeSet 可以按照元素的自然顺序排序
底层是红黑树
*/
TreeSet<String> tset = new TreeSet<String>();
tset.add("b");
tset.add("a");
tset.add("d");
tset.add("c");
tset.add("x");
/*
* Set遍历方式
*/
//tset.stream().forEach((a)->System.out.print(a));
/* for (String t : tset) {
System.out.println(t);
}*/
Iterator<String> it = tset.iterator();
while(it.hasNext()){
String e = it.next();
System.out.println(e);
}
}
}Map双列集合
HashMap
public static void main(String[] args) {
/*
map集合
键 值 对存储
HashMap键是无序的
*/
HashMap hashMap=new HashMap();
hashMap.put(1,"a");
hashMap.put(1,"b");//如果有重复的键 后面的值会把前面的覆盖掉
hashMap.put(4,"a");
hashMap.put(3,"a");
hashMap.put(2,"a");
hashMap.put(null,"d");//可以存储一个键为null的元素
hashMap.put(null,"e");
System.out.println(hashMap);
System.out.println(hashMap.containsValue("e"));
System.out.println(hashMap.containsKey(3));
hashMap.clear();
System.out.println(hashMap.isEmpty());
System.out.println(hashMap);
}TreeMap 键是按照自然顺序排列
HashTable
public static void main(String[] args) {
TreeMap<Integer,String> treeMap=new TreeMap();//键是按照自然顺序排列
treeMap.put(1,"a");
treeMap.put(5,"a");
treeMap.put(4,"a");
treeMap.put(2,"a");
treeMap.put(3,"a");
treeMap.put(3,"d");//若键中有重复元素 后面的值会覆盖前面的值
//treeMap.put(null,"d");
/*
键的类型如果是自己创建的类 要实现comparble 接口
不允许存储键为null的
*/
System.out.println(treeMap);
// Hashtable初始容量为11 0.75 线程安全 无序
Hashtable <String,String>hashtable=new Hashtable();
hashtable.put("c","a");
hashtable.put("b","a");
hashtable.put("a","a");
hashtable.put("b","b");
hashtable.put("3","a");
hashtable.put("3","d");//若键中有重复元素 后面的值会覆盖前面的值
//hashtable.put(null,"c");不允许存储键为null的
System.out.println(hashtable);
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
