Java学习笔记7

set集合

Set和List都是容器但List有序Set无序

有序和无序  取出的顺序和添加进入的顺序是一样的就是有序

基本用法

实例化Set集合

HashSet set = new HashSet();

放入数据

        set.add("23");

删除数据

        set.remove("123");

存储了多少个数据

        set.size();

规则

Set中不能存储相同的数据,List可以       

 set.add("23");

int size = set.size();

System.out.println(size);

只要是类型相同数值相同就会被认为是同一个对象        

set.add(456);//456存入的是Integer类型

set.add(456);

size = set.size();

System.out.println(size);

set.add(null);

size = set.size();

System.out.println(size);

遍历

for (Object item : set) {

      System.out.println(item);

}

//TreeSet   红黑树

        TreeSet tset = new TreeSet();

//存入数据

tset.add(2);

tset.add(200);

tset.add(3);

tset.add(88);

tset.add(45);

tset.add(72);

tset.add(99);

tset.add(1);

//不能存null值

//        tset.add(null);//语法通过,但报错

遍历

for (Object item : tset) {

     System.out.print(item + ",");

}

补充

        //二叉树遍历方法有先序遍历 ,中序遍历  ,后序遍历

        //TreeSet用的是中序遍历

        //TreeSet  内部使用二叉树  内部节点是可以比较大小的

        //同一个TreeSet对象中储存的内容都应该是可以比较的

        //默认情况下不能存储不同类型

先序

中序

后序

LinkedHashSet  是有序的集合Set

TreeSet<Student> ttset = new TreeSet<>(com);

Student stua = new Student();

stua.score = 89;

Student stub = new Student();

stua.score = 77;

Student stuc = new Student();

stua.score = 86;

Student stud = new Student();

stua.score = 75;

ttset.add(stua); ttset.add(stub); ttset.add(stuc); ttset.add(stud);

        for(Student stu:ttset){

            System.out.println(stu.score);

        }
class Student implements Comparable {



        int score;



        @Override

        public int compareTo(Object o) {

            if (o instanceof Student) {

                Student item = (Student) o;

                if (this.score < item.score) {

                    return 0;

                }

                return this.score >item.score?1:-1;

            }else{

                //o对象不是Student就无法比较  这是程序运行时出现的特殊情况

                //这种特殊情况我们叫做异常情况我们的方法处理不了这种业务,就要抛出一个异常对象

                //告知调用此方法的代码

                throw new RuntimeException("传入对象无法比较");

            }

        }

}

Map

存储键值对  键--名字  值--存储的对象

基本用法

定义

Map map=new HashMap();

存放数据

map.put("A1","张三");

可以通过存入的key获取存入的对象        

map.get("A1");//获取A1对应的value值

        Object obj=map.get("A1");

        System.out.println(obj);

可以通过key来删除键值对,remove会返回删除的值value  

Object rem_obj= map.remove("A1");

System.out.println(rem_obj);

是否包含key

map.containsKey("A1");

是否包含某一个值

map.containsKey("张三");

获取所有的key

Set setkey=map.keySet();

获取所有的value        

Collection con= map.values();

map.put(null,null);

map.put("A1",null);

System.out.println(map);

特殊规则

Map的key是唯一的

TreeMap中null不能是key

key应该是可比较的        

Hashtable ht = new Hashtable();

ht.put("t1","张三");

Hashtable他的key和value都不能是null

Hashtable是线程安全的集合        

LinkedHashMap lMap=new LinkedHashMap();

lMap.put("t1",null);

ConcurrentHashMap  线程安全  效率较高

ConcurrentHashMap chm;

HashMap  底层实现   数组加链表

HashMap hmap = new HashMap();

hmap.put("","");

HashMap 的数组默认容量是16

每次扩容2倍

扩容阈值 0.75    第一次存入12个元素后就扩容

一个链上的元素达到8就对该链进行数化

一直树上的元素低于6,这个树就会退化成链

最小数化容量阈值 64 扩容两次以后才会触发树化

如果数组长度没有达到64 优先扩容

线程安全的Map  Hashtable  ConcurrentHashMap(性能优异,锁颗粒度比较小)

泛型

泛型  广泛的数据类型

确保类型安全的一种途径

定义  在类和方法上都可以使用泛型

基本用法

private M m;//在属性上使用泛型

    public void test(M m,N n){//定义泛型并在类中或方法中使用

    }

    public static <J extends List> J testA(J j){

        return j;

    }

在方法上定义泛型

    public<E> E test(E e){

        //返回的类型和传入的类型是相同的

        return e;

}

其他

在类型转换时没有明确知道对象的数据类型进行强制数据类型转换

会抛出类型转换异常(ClassLaseException)

类型不安全

for(Object object : list){

            String str = (String)object;

            System.out.println(str);

        }



        List<String> listA = new ArrayList<>();

        listA.add("123");



        Map<String,Object> map = new HashMap<>();

        //只要是泛型就是对象
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值