Java容器类

小灰灰 2021-09-20 20:56 358阅读 0赞

/\*  
1，表格数据储存  
JavaBean  
可以创建一个类表示一个实例，用Javabean封装一下，  
在创建这个类的对象，一个对象代表一条数据，一个类对应一个一个表结构  
HashMap  
一个Map对应一条数据，一个Array List对应一个表

2，迭代器  
//用迭代器遍历数组

3，泛型

*  一，安全：编译时检查类型安全；
 *  二，所有类型转化都是自动的和隐式的，提高代码重用率
 *  不使用泛型
 *  //需要人为的进行类型转化，容易转换错误
 *  //所以需要使用泛型  
    \*泛型类，声明时使用泛型类  
    \*理论上是可以随便写  
    \*T Type表示数据类型  
    \*K V K表示key,V表示value  
    \*E指的是element 元素  
    \*注意  
    \*  
    \*extends 表示小于等于（大概是子类的意思）  
    \*通配符？的使用
 *  声明方法上，不能声明类，使用时
 *  ?类型不定，使用时确定,只能接受和输出，不能修改
 *  ？ extends ：<=上限 指定类型为子类或自身
 *  ? super : >=下限 指定类型为父类或自身  
    \*泛型是在使用时才可以确定具体类型  
    \*泛型类只能是引用类型，不能是基本类型  
    \*泛型声明时声明时不能使用静态属性或静态方法如，T static a；是错的
 *

\*接口中，泛型字母只能使用在方法中，不能使用在全局变量里T static a；是错的  
\*public static void test (t… a)  
\*在泛型方法中 修饰符<字母> 返回类型 方法名 （字母）\{ \}  
\*在方法中只能访问对象信息，不能修改对象信息

4，泛型的擦除  
//子类，父类为泛型类时  
//类型在子类使用时确定  
//子类泛型类型要大于等于父类的类型类型  
//就是泛型可以比父类多，但是绝对要包含父类中有的泛型  
//public class Child <T1,T> extends Father\{  
// @Override  
// public void test(T t) \{  
//  
//  
// \}  
//\}

//子类为泛型类时，父类不指定类型，父类泛型的擦除，泛型类型自动转化为Object类型

//public class Child extends Father\{  
// public void test(Object t) \{  
// \}  
//\}  
//子类父类不指定类型，子类父类同时泛型的擦除，泛型类型自动转化为Object类型  
//  
//public class Child extends Father\{  
// String name;  
// public void test(Object t) \{  
// \}  
//\}  
//不能只擦除子类的泛型，下面是错误的  
//public class Child extends Father\{  
// @Override  
// public void test(Object t) \{  
// \}  
//\}

*  子类在声明是要制定具体类型
 *  类型属性为具体类型
 *  方法属性也要为具体类型
 *  
 *  
 *  泛型接口在擦除时也是相同的
 *  
 *  
 *  擦除不进行类型检查
 *  
 *  子类父类的擦除，要么同时擦除要么只擦父类，不能只擦子类
 *  子类为泛型类时，父类为泛型时
 *  子类要大于等于父类的类型
 *  就是泛型可以比父类多，但是绝对要包含父类中有的泛型
 *  
 *  属性类型
 *  父类中随父类而定
 *  子类中随子类而定
 *  方法重写
 *  随父类而定
 *

\*没有泛型数组  
\*声明可以使用，但是创建失败  
\*  
\*可以在类中进行类型转换

5，排序  
1，冒泡排序  
双层for循环注意第二层  
for(int i=0;i<arr.length;i++) \{  
for(int j=0;j<arr.length-1-i;j++) \{

6，compareTo方法  
比照两个的大小，不同的类重写了不同的compareTo方法

7.内置引用类型

*  一 实体类
 *  java.lang.Comparable,重写compareTo
 *  
 *  public class NewItem implements Comparable\{
 *  public int compareTo(NewItem o) \{  
    //比较时间  
    int result =-this.date.compareTo(o.date);//降序  
    if(0result) \{  
    //时间相同点击量  
    result =this.hites-o.hites;//升序  
    if(0result) \{  
    //点击量相同比较标题  
    result=-this.title.compareTo(o.title);//降序  
    return result;
    
        }
         }
         
         return result;
    
    \}
 *  二 业务排序类
 *  java.util.Comparator重写compare
 *

public class GoodsPriceComp implements Comparator\{  
先实现接口，在重写compare方法  
最后通过Collections.sort(list, new GoodsPriceComp())使用  
@Override  
public int compare(Goods o1, Goods o2) \{  
// 两次三目运算符  
return -((o1.getPrice()-o2.getPrice())>0?1:(o1.getPrice()==o2.getPrice()?0:-1));  
\}

\}  
Collections.sort(list, new GoodsPriceComp());

*  用于引用类型的排序
 *  解耦，与实体类分离
 *  方便：应对多变的排序
 *  TreeSet 特点 不可重复，可排序，容器类
 *  是Set接口的实现类
 *  去重，比较等于零及重复
 *  1，元素可以排序java.lang.Comparable重写compareTo方法
 *  new TreeSet()
 *  2，排序业务类 java.util.comparator重写compare方法
 *  new TreeSet(Comparator<? super E> comparator)
 *  TreeSet在添加数据时排序，排序之后更改数据不会改变排序  
    \*TreeSet在过程中不要修改数据，不然可能会重复  
    \*可以把实体类属性，定义成final
 *  HashSet是另一个set的实现类
 *  元素必须重写Hashcode和equals方法

引用分类

*  强引用：使用强引用，在内存不足的时候垃圾处理器也不会回收他，哪怕导致程序崩溃 例如： A a=new A（）

软引用：内存不足的时候会被回收（软引用可以和一个引用队列（ReferenceQueue）  
联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。  
）————一般用来构建敏感信息的缓存

弱引用：只要垃圾处理去扫描到有弱引用对象，内存足不足都要被回收  
（可以和一个引用队列（ReferenceQueue）联合使用，  
如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。）

虚引用：任何时候都会被回收，形同虚设（而且必须要和引用队列联合使用）  
\*  
\*

*  三个Map接口的实现类
 *  WeakHashMap键为弱引用
 *  IdentityHashMap；键比较地址去重，注意常量池对象
 *  EnumMap：要求键为枚举的值

同步容器  
synchronizedList(List list)  
返回由指定列表支持的同步（线程安全）列表。  
synchronizedMap(Map<K,V> m)  
返回由指定地图支持的同步（线程安全）映射。  
synchronizedSet(Set s)  
返回由指定集合支持的同步（线程安全）集。

容器的只读设置

*  只读设置
 *  emptyXxx() 空的不可变的集合  
    emptySet()  
    返回一个空集（immutable）。  
    emptyMap()  
    返回空的地图（不可变）。  
    emptyList()  
    返回空列表（immutable）。
 *  singletonXxx（） 一个元素不可变的容器，不能加别的元素  
    singletonList(T o)  
    返回一个只包含指定对象的不可变列表。  
    singletonMap(K key, V value)  
    返回一个不可变的地图，只将指定的键映射到指定的值。  
    singleton(T o)  
    返回一个只包含指定对象的不可变集。  
    Map <String,String> map1=Collections.unmodifiableMap(map);
 *  unmodifiableXxx（）不可变的容器  
    unmodifiableList(List<? extends T> list)  
    返回指定列表的不可修改视图。  
    unmodifiableMap(Map<? extends K,? extends V> m)  
    返回指定地图的不可修改视图。  
    unmodifiableSet(Set<? extends T> s)  
    返回指定集合的不可修改视图。

Collections类的常用方法

*  java.util.Collections
 *  Collections,工具类
 *  
 *  重要方法
 *  binarySearch(List<? extends Comparable<? super T>> list, T key)
 *  前提是容器有序，否则查找可能出错，使用二叉搜索算法搜索指定对象的指定列表。
 *  
 *  sort(List list, Comparator<? super T> c)
 *  根据指定的比较器引起的顺序对指定的列表进行排序。
 *  
 *  reverse(List<?> list)
 *  反转指定列表中元素的顺序。
 *  
 *  shuffle(List<?> list) 模拟洗牌过程
 *  使用默认的随机源随机排列指定的列表。
 *  
 *  swap(List<?> list, int i, int j)
 *  交换指定列表中指定位置的元素。

Enumeration的使用

*  类似于迭代器、
 *  方法
 *  1.hasMoreElements（）
 *  2.nextElement（）
 *  
 *  Vector的elements方法
 *

Enumeration en =vec.elements();  
while(en.hasMoreElements()) \{  
System.out.println(en.nextElement());  
\}

*  Vector类实现了可扩展的对象数组。
 *  像数组一样，它包含可以使用整数索引访问的组件。
 *  但是， Vector的大小可以根据需要增长或缩小，以适应在创建Vector之后添加和删除项目。

Enumeration的子类

*  StringTokenizer：类似于String 的split方法
 *  用于字符串的分割，但不支持正则表达式
 *  
 *  StringTokenizer(String str, String delim)

Map

*  Map
 *  存放键值对，
 *  根据键对象找值对象
 *  键不能重复  
    map的底层是数组加链表，先根据HashCode判断大概，再根据Equals判断是否相等  
    重写HashCode时必须重写Equals
 *  “map分拣”思路
 *  1，为所有key创建对象容器
 *  之后容器中存放对应的value
 *  2，第一次创建容器，并存放value
 *  第二次之后直接使用容器存放值

EnumMap要求键为枚举  
HashMap线程不安全，效率高

*  HashTable线程安全，效率不高
 *  Hashtable和HashMap的区别
    
     *  Hashtable是线程安全的，效率相对低下，同步
     *  Hash Map是线程不安全的，不同步，效率较高
     *  Hash table父类是Dictionary
     *  HashMap父类是AbstractMap
     *  Hashtable键和值不能为空
     *  HashMap键最多一个null，值可以多个null
     *  2
     *  Hashtable的子类Properties
     *  作用：读写资源配置文件
     *   *  根据类路径加载资源文件
     *  1，类.class.getResourceAsStream("/~~~~~")
     *  2，Thread.currentThread().getContextClassLoader().getResourceAsStream("~~~~~~")
     *  键与值只能为字符串
     *  方法
     *  setProperty(String key, String value)  
        致电 Hashtable方法 put 。
     *  getProperty(String key, String defaultValue)  
        使用此属性列表中指定的键搜索属性。 //不存在是返回后面的字符串
     *  getProperty(String key)  
        使用此属性列表中指定的键搜索属性。//不存在时返回空
     *  
     *  
     *  后缀
     *  .properties
        
         *  store(OutputStream out, String comments) UTF-8字符集  
            将此属性列表（键和元素对）写入此 Properties表中，  
            以适合于使用 load(InputStream)方法加载到 Properties表中的格式输出流。
         *  store(Writer writer, String comments)  
            将此属性列表（键和元素对）写入此 Properties表中，  
            以适合使用 load(Reader)方法的格式输出到输出字符流。
         *  load(InputStream inStream)  
            从输入字节流读取属性列表（键和元素对）。  
            \*load(Reader reader)  
            以简单的线性格式从输入字符流读取属性列表（关键字和元素对）。
     *  
     *  
     *  
     *  .xml
        
         *  storeToXML(OutputStream os, String comment)  
            发出表示此表中包含的所有属性的XML文档。
         *  storeToXML(OutputStream os, String comment, String encoding)  
            使用指定的编码发出表示此表中包含的所有属性的XML文档。
         *  loadFromXML(InputStream in)  
            将指定输入流中的XML文档表示的所有属性加载到此属性表中。

\*IdentityHashMap  
\*键比较地址去重

Set  
Set是无序不可重复  
HashSet底层代码以map实现，add(e)把e添加为map的键值key，所以set不能重复

队列queue  
使用队列模拟银行存款业务  
\*  
\*  
offer(E e)  
如果在不违反容量限制的情况下立即执行，则将指定的元素插入到此队列中。

element()  
检索，但不删除，这个队列的头。

add(E e)  
将指定的元素插入到此队列中，如果可以立即执行此操作，而不会违反容量限制，  
true在成功后返回 IllegalStateException如果当前没有可用空间，  
则抛出IllegalStateException。

peek()  
检索但不删除此队列的头，如果此队列为空，则返回 null 。

poll()  
检索并删除此队列的头，如果此队列为空，则返回 null 。

remove()  
检索并删除此队列的头。

单向  
抛出异常的方法  
add插入  
remove移除  
element读取  
返回空值的方法  
offer插入  
poll移除  
peek获取

双向

抛出异常的方法  
add（first/last)插入  
remove（first/last)移除  
element（first)读取  
get（first/last)获取  
返回空值的方法  
offer（first/last)插入  
poll（first/last)移除  
peek（first/last)获取

List中是有序可重复  
\*ArrayList底层实现用数组，所以查询快，修改，插入，删除慢,  
\*LinkedList 底层实现用链表，所以查询满，修改，插入，删除快  
\*  
\*  
\*list.size()方法是返回list中的对象数，而不是返回索引，是索引的最大值加一  
\*Vector 线程安全的，效率低

*  \*/