JAVA第六章--集合(单列,双列)

数组特点:

一组数据类型相同的元素集合

创建数组时,必须给定长度,而且一旦创建长度不能改变,

一旦数组装满元素,需要创建一个新的数组,将元素复制过去

不方便:判断

单列集合:

一次放进去一个值(对象)

Collection:定义单列集合共有放法

List:可以有重复元素

ArraysList:数组列表

底层有一个数组,可以动态扩展数组长度,并提供一系列方法操作

查询快

中间增加,删除慢

add(E,e)默认向末尾添加元素

  arrayList.add("a");

    arrayList.add(1,"b");
    arrayList.remove("a");
   // System.out.println(arrayList.remove("x"));根据内容删除匹配的第一个元素,删除成功返回true,否则返回false
    //System.out.println(arrayList.remove(1));删除并返回指定位置元素
    //System.out.println(arrayList.get(1));获取指定位置上的元素
    System.out.println(arrayList.indexOf("d"));
    //System.out.println(arrayList.lastIndexOf("d"));
    //System.out.println(arrayList.set(2,"x"));替换并返回指定位置上的元素
    arrayList.clear();
    System.out.println(arrayList.isEmpty());
}
arrayList遍历:
1.增强for循环
for(String s:arrayList){
    System.out.println(s);
}
2.普通for循环(可以修改数组)
for(int i=0;i< arrayList.size();i++){
    if("a".equals(arrayList.get(i))){
        arrayList.remove(i);
    }
}
使用迭代器遍历数组
ArrayList<String> arrayList=new ArrayList();
arrayList.add("a");
arrayList.add("a");
arrayList.add("a");
arrayList.add("a");
arrayList.add("a");
Iterator<String> it=arrayList.iterator();
while(it.hasNext()){
    String s=it.next();
    if(s.equals("a")){
        it.remove();
    }

LinkeList:链表列表

底层是一个链表结构

查询慢

增加,删除快

LinkedList<String> linkedList=new LinkedList();
linkedList.add("a");
linkedList.add("b");
linkedList.add("c");
linkedList.add("d");
linkedList.add("e");
linkedList.add("f");
linkedList.add(1,"x");
System.out.println(linkedList);
linkedList.removeFirst();
System.out.println(linkedList);
System.out.println(linkedList.get(1));
linkedList.clear();
System.out.println(linkedList);
迭代器遍历链表
 ListIterator<String> iterator= arrayList.listIterator(arrayList.size());
      while (iterator.hasPrevious()){
          System.out.println(iterator.previous());
      }*/

set

创建一个compareto接口的匿名内部类对象

ArrayList<Integer> list=new ArrayList<>();
Collections.addAll(list,1,2,4,5,3);
Collections.sort(list, new Comparator<Integer>() {//创建一个compareto接口的匿名内部类对象,就是省去一个创建类,简化语法
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2.intValue()-o1.intValue();
    }
});
//Collections.sort(list);
System.out.println(list);
System.out.println(Collections.binarySearch(list, 1));
treeset:
不能存储重复元素的
可以根据值进行排序,底层使用了树形结构,树结构本身就是有序的,
向树形结构中添加元素是,如何判断元素大小以及元素是否重复
向TreeSet中添加的元素类型必须实现Compare接口,重写compareTo(),
每次添加元素时,调用compareTo进行元素大小判断(小于0放左子节点,等于0表示重复,大于0放在右子节点)
TreeSet<Integer> tree=new TreeSet<>();
tree.add(1);
tree.add(5);
tree.add(4);
tree.add(2);
tree.add(1);
tree.add(3);
System.out.println(tree);
  TreeSet<student> treeSet=new TreeSet<>();
// student str1=new student("张三",100);
   student str2=new student("李四",101);
   student str3=new student("王五",102);
   student str4=new student("张三",100);
   student str5=new student("李三",105);
   treeSet.add(new student("张三",100));
   treeSet.add(str2);
   treeSet.add(str3);
   treeSet.add(str4);
   treeSet.add(str5);
   System.out.println(treeSet);
hashset

会按照hashcode排序

HashSet<student> hashSet=new HashSet<>();
hashSet.add(new student("张三",100));
hashSet.add(new student("李四",101));
hashSet.add(new student("王五",102));
hashSet.add(new student("张柳",103));
hashSet.add(new student("张三",100));
System.out.println(hashSet);

双列集合:

键 值

Map接口共性
数据存储是键,值是形式存储
键不能重复的,值是可以重复
通过键可以找到值
一个键只能映射一个值
HashMap
键是无序的
       HashMap<String,Integer> hashMap=new HashMap<>();
        hashMap.put("d",10);
        hashMap.put("b",101);
        hashMap.put("c",102);
        hashMap.put("a",10);
        hashMap.put("a",102);
        System.out.println(hashMap);
        //hashMap.clear();
        System.out.println(hashMap.containsKey("c"));
        System.out.println(hashMap.remove("a"));
        System.out.println(hashMap.isEmpty());

1.底层使用一个长度默认为16的数组,用来确定元素的位置,每次用key计算出哈希值,用哈希值%数组长度确定元素位置,将元素放在哈希表中指定位置,

2.后来继续添加元素,如果出现相同位置且不重复的元素,那么后来的元素添加到之前元素的next节点

3.当连表长度等于8时,且哈希数组长度大于64链表才会转为红黑树

4.哈希表负载因子为0.75,当哈希表使用数组0.75时,会自动扩容为原来数组长的2倍。

hashtable

Hashtable
底层实现也是用到key的哈希值,计算位置,判断元素是否重复
方法上都添加了synchronized锁
Hashtable中不能存储为NULL的键和为NULL的值

HashMap可以存储一个为NULl键,值可以为null.
Hashtable<String,String> hashtable=new Hashtable<>();
hashtable.put("ad","ad");
hashtable.put("ad","ad");
hashtable.put("d","d");
hashtable.put("a","a");
hashtable.put("aad","aad");
System.out.println(hashtable);

treemap

/*
TreeMap
顶层使用树形结构存储键值
键可以排序
键元素类型必须实现Comparable接口,重写compareTo()方法
     */
public static void main(String[] args) {
    TreeMap<Integer,String> treeMap=new TreeMap<>();
    treeMap.put(1,"aa");
    treeMap.put(2,"ab");
    treeMap.put(1,"aaa");
    treeMap.put(4,"ba");
    treeMap.put(5,"aca");
    System.out.println(treeMap);
   /* treeMap.ceilingKey(1);
    treeMap.isEmpty();
    treeMap.size();
    treeMap.get(1);*/
    //map遍历
    //方法1:先拿到所有的键 遍历键 根据键找值

    Set<Integer> keySet=treeMap.keySet();
    for(Integer key:keySet){
        System.out.println(key+":"+treeMap.get(key));
    }
    //方法二:推荐遍历方法
    Set<Map.Entry<Integer,String>> entries=treeMap.entrySet();
    for(Map.Entry entry:entries){
        System.out.println(entry.getKey()+":"+entry.getValue());
    }
}

泛型

什么是泛型?

● 泛型,即“参数化类型” 。一提到参数,最熟悉的就是定义方法时有形 参,然后调用此方法时传递实参。

● 参数化类型,就是将类型由原来的具体的类型参数化,类似于方法中的 变量参数,此时类型也定义成参数形式,然后在使用/调用时传入具体的 类型。

● Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编 译时类型安全检测机制,泛型的好处就是在编译的时候能够检查类型安 全。

泛型类

泛型类型用于类的定义中,被称为泛型类。通过泛型可以完成对一组类的操作对外开 放相同的接口。

一个最普通的泛型类: public class Demo{ / /T可以为任意标识符,常见的如T、E、K、V等形式的参数常用于表示泛型 private T key; / /key这个成员变量的类型为T,T的类型由外部指定 public Demo(T key) { / /泛型构造方法形参key的类型也为T,T的类型由外部指定 this.key = key; } public T getKey(){ / /泛型方法getKey的返回值类型为T,T的类型由外部指定 return key; } }

传入的实参类型需与泛型的类型参数类型相同,即为Integer. Demo demo = new Demo(123456);

1.泛型的类型参数只能是类类型

2.泛型的类型参数可以有多个。

3.如果没有定义具体类型,默认为Object

从泛型类派生子类

子类也是泛型类,子类和父类的泛型类型要一致 class A extends Demo 子类不是泛型类,

父类要明确泛型的数据类型 class A extends Demo

泛型接口

泛型接口与泛型类的定义及使用基本相同。

public interface Demo { //定义一个泛型接口 } 子类也是泛型类,

子类和父类的泛型类型要一致 class A implements Demo{ } 子类不是泛型类,

父类要明确泛型的数据类型 public class A implements Demo { }

  • 26
    点赞
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值