core java--day10(基本数据类型与包装器类型，自动装箱与拆箱，集合从属关系，hashset与treeset，自然排序与客户端排序)

于 2019-08-18 10:55:24 发布
阅读量272 收藏
点赞数
分类专栏： java 文章标签： 基本数据类型与包装器类型 自动装箱与拆箱 集合从属关系 hashset与treeset 自然排序与选择排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41533897/article/details/99702214
版权

复习：

匿名内部类
  继承父类:
      F f = new F(){
        public void show(){
        syso
    }
      };
  实现接口:
      I i = new I(){
    实现所有的方法
      };

String 类使用
   char[] value;

   StringBuffer -->  
    
    StringBuffer sb = new StringBuffer();

    StringBuild sb = new StringBuild();

    sb.append("hello");
    sb.append("world");
    String msg = sb.toString();

构造器 :
   String msg = new String(but,0,len);
   String msg = new String("hello");
方法 : 
   char = charAt(index);
   int = msg.indexOf("字符串");
   int = msg.lastIndexOf("字符串");

   String = msg.substring(beginIndex);
   String = msg.substring(beginIndex,endIndex);
   
   String[] = msg.split("规则");

   boolean  = msg.matches("规则");
   String msg = "hello world";
   msg.matches("hello [A-z]{5}");//false
  
    String msg = "   hel  he wo ld   h  ";
    msg.trim();
    msg.replace(" ","");

基本数据类型与包装器类型
    注意 : 包装器类型都重写了equals方法
    9.1:
    boolean        Boolean
    byte        Byte
    short        Short
    char        Character
    int        Integer
    long        Long
    float        Float
    double        Double

    Integer  int类型的包装器类型
    "123"-->int

    字符串转化为 数字
      int =  Integer.parseInt("123");
      lont = Long.parseLong("123")
    数字转换为字符串
          String s = ""+10;


    9.2:自动装箱和自动拆箱
    在jdk1.5以后 基本数据类型和其包装器类型之间有自动装箱和拆箱过程。
    注：是发生在编译阶段。
    9.2.1:自动装箱: Integer i1 = 128;  ---->  Integer i1 = Integer.valueOf(128);
            Integer i2 = 127;  ---->  Integer i2 = Integer.valueOf(127);
    9.2.2:自动拆箱:    int a1 = i1;       ---->  int a1 = i1.intValue();
            int a2 = i2;       ---->  int a2 = i2.intValue();

    9.2.3:valueOf():
        源码：
        IntegerCache.low = -128
        IntegerCache.high = 127
        cache 缓存

        public static Integer valueOf(int i) {
            assert IntegerCache.high >= 127;
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
            }
        结论：自动装箱的时候，如果这个数字在[-128~127]之间那么就是从缓存中获取数据。
                      如果这个数字不在范围内，那么就是利用new关键字创建Integer对象()
            
        问题一：Integer a =  128 ,  Integer b = 128;a == b ?--->false  
                        Integer a =  127 ,  Integer b = 127;a == b ?--->true

        9.2.4:intValue(): 以 int 类型返回该 Integer 的值。即返回的是栈中 字面量同的地址。
            
            结论:自动拆箱的时候，返回的是栈中字面量同的地址。即： int n;
        9.2.5:什么时候回发生自动装箱/拆箱问题。
            9.2.5.1:当int 和 Integer互相转换的时候回发生。
                eg: int a = new Integer("12");
                eg: Integer b = 10;
    *   9.3:Integer.parseInt("全数字字符串");
        把全数字的字符串转为int类型数据
        eg:int a = Integer.parseInt("123");---> int : 123;
    9.4:Integer.MAX_VALUE : 它表示 int 类型能够表示的最大值。
    9.4:Integer.MIN_VALUE : 它表示 int 类型能够表示的最小值。
    9.4:Integer.SIZE      : 用来以二进制补码形式表示 int 值的比特位数。

package com.briup.ch10;

/**
 * 测试自动装箱和拆箱
 */
public class Test1 {

	public static void show(Integer age) {
		System.out.println(age);
	}

	public static void main(String[] args) {
		Integer i = new Integer(10);
		Integer i2 = new Integer("20");

		show(i);
		show(i2);
		// 自动装箱 : int类型 自动转换为 Integer
		// show(Integer.valueOf(30));
		show(30);

		Integer i3 = new Integer("32");
		int intValue = i3.intValue();
		// 自动拆箱 : Integer类型 自动转换为 int类型
		// int i4 = i3.intValue();
		int i4 = i3;

		Integer i7 = new Integer(127);
		Integer i8 = new Integer(127);
		System.out.println(i7 == i8);// false

		// 坑 自动装箱的问题
		Integer i5 = Integer.valueOf(127);

		Integer i6 = Integer.valueOf(127);

		System.out.println(i5 == i6);// true

		Integer.valueOf(19);

		Integer i9 = Integer.valueOf(128);
		Integer i10 = Integer.valueOf(128);
		System.out.println(i9 == i10);// false

		// 常见使用:
		// 利用parseInt() toString() 进制转换

		// 2 1010 ---> 16

		// 2 1010 --->10 数
		// 10数 ----> 16 进制的数
		int aaa = 01010;// 8进制
		int bbb = 0x1010;// 16进制

		String s2 = "1011";
		// 使用Integer.parseInt(字符串,该字符串是多少进制的数)
		// 转换为 10 进制的数
		int parseInt = Integer.parseInt(s2, 2);
		System.out.println(parseInt);

		// 把10进制的数转换为 16 进制
		// 参数1 ：数字
		// 参数2 ：把该数字 用某进制 转换为 字符串
		String string = Integer.toString(parseInt, 16);
		System.out.println(string);

		System.out.println(Byte.MAX_VALUE);
		System.out.println(Byte.MIN_VALUE);
		
		
		
		
		// int 中 的 最大值
		int maxValue = Integer.MAX_VALUE;
		System.out.println(maxValue);
		int min = maxValue - 10;
		for (int j = min; j<= maxValue; j++) {
			System.out.println(maxValue);
		}
		/**
		  *  经过高手指教<br>
		  *  发现其中问题，<br
		 * 1,Integer.MAX_VALUE 就是最大值，值不会改变。
		 * 2,当j == MAX_VALUE 时，再加上1 就超过了 int的范围，导致j 变成了负数
		  *  注: 具体 参考下面三个打印
		 * */
		//2147483647
		//0111 1111 1111 1111 1111 1111 1111 1111
		System.out.println(Integer.MAX_VALUE);
		//-2147483648
		//1000 0000 0000 0000 0000 0000 0000 0000 //它前面实际上还有一个符号位0，因为位数不够，所以变成了负数
		System.out.println(Integer.MAX_VALUE+1);
		//-2147483648
		//1000 0000 0000 0000 0000 0000 0000 0000
		System.out.println(Integer.MIN_VALUE);
		
	}
}


集合：
    10.1:数组的升级版.--->集合  =  数组/其他内存结构  +  可变长度  +  一堆方法  +  简单操作。
    10.2:集合位于java.util包中
        
    注意：集合只能存放引用数据类型的数据。

10.3:集合分类 
   10.3.1: Set : 
       1,无序
       2,对象不能重复
   10.3.2: List: 
       1,有序(放入的先后的次序), 
    2,对象可以重复。
   10.3.3: Map : 
      集合中的每一个元素包含
      一对键对象和值对象，
    1,集合中没有重复的键对象，
    2,值对象可以重复。(Key - Value)
      注: 可能存在 value相同，key不同的情况

    10.4:集合的从属关系
    ________________________________________________________________________________
    |                                                                                                                                                                                  |
    |    父接口            子接口        实现类                                                                                                                      |
    |_______________________________________________________________________________|
    |                                                                                                                                                                                  |
    |                                                    |------>HashSet                                                                                                     |
    |                             |------>Set-----|------>TreeSet                                                                                                      |
    |                             |                      |------>LinkedHashSet    自己了解                                                                     |
    |                             |                                                                                                                                                    |
    |    Collection------|                      |------>ArrayList                                                                                                    |
    |                             |------>List----|------>Vector       自己了解                                                                                  |
    |                                                   |------>LinkedList 自己了解                                                                                 |
    |_______________________________________________________________________________|
    |                                                                                                                                                                                  |
    |                                                     |------>HashMap                                                                                                  |
    |    Map--------------------->Map----|------>TreeMap                                                                                                   |
    |                                                     |------>Hashtable  自己了解                                                                               |
    |                                                                                                                                                                                  |
    |_______________________________________________________________________________|    

    10.5:涉及集合的基本操作
        10.5.1 :  向集合中添加数据.
        10.5.2 :  从集合中取数据
        10.5.3 :  获得集合长度
        10.5.4 :  遍历集合
        10.5.5 : 清空集合
        10.5.6 : 删除集合中某一个数据

    10.5 : Collection接口
         Collection接口 声明了 Set接口 和List接口 的通用方法.
        10.5.1 : boolean add(Object o)    向集合中添加数据
        10.5.2 : Iterator iterator();    获取集合的迭代器(迭代器用来遍历集合);
        10.5.3 : int size();        返回集合中元素的数目；
        
        10.5.4 : void clear()           删除集合中的所有对象引用，即不再持有这些对象的引用；
        10.5.5 : contains(Obj)        判断在集合中是否持有特定对象的引用；
        10.5.6 : isEmpty()              判断集合是否为空；
        10.5.7 : remove(Obj)        从集合中删除一个对象的引用；
        10.5.8 : Object[] toArray()     返回一个数组，该数组包含集合中的所有元素；
    
    10.6 : Iterator接口(用于遍历Collection集合):迭代器。
        主要方法:
        hasNext()    是否有下一个元素        
        next()        获取下一个元素
        remove()    删除当前元素

    10.7 : Set : 集合中的对象无序、不能重复;--->注意：是通过equals方法比较对象是否相同。
        10.7.1 : HashSet:按照哈希算法来存取集合中的对象，存取速度比较快;
        10.7.2 : TreeSet:实现SortedSet接口，具有***排序功能***；
        10.7.3 : LinkedHashSet:HashSet子类，不仅实现Hash算法，还实现链表数据结构，链表数据结构能提高插入和删除元素的性能；
        
        10.7.4 : 集合操作实例
            Set set = new HashSet();
            set.add("小明");
            set.add("小红");
            set.add("小红");
            set.add("小红1");
            set.remove("小红");    
            set.size();
            Interator it = set.iterator();
            while(it.hasNext()){
                String name = (String)(it.next());//小明 小红
            }
        10.7.5 : HashSet : 先 hashCode() &&  后 equals() 同时满足这两个才被hashSet认为是同一个对象。

             按照哈希算法来存取集合中的对象，存取速度比较快。当向集合中加入一个对象时，HashSet会调用对象的hashCode()方法来获得哈希码，然后根据这个哈希码进一步计算出对象在集合中的存放位置。
            ---> 两个对象的值相同(equals()比较相同) ,那么这两个对象的hashCode一定相同。
            ---> 两个对象的hashCode相同，那么这两个对象的值不一定相同。

             jdk1.8以后，往hashset中插入新数据，是从对应链表最后插入，1.8以前，是从前端插入。hashmap底层是数组与单链表结构，next是指向下一个的，如果通过hashcode与equals比较都相同，即判断为同一个元素，那么就会直接覆盖，之前的数据不再存在

package com.briup.ch10;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * HashSet测试
 */
public class Test2 {
	public static void main(String[] args) {
		//创建HashSet集合
		/*
		 * 无序 不能重复
		 * */
		Set set = new HashSet();
		//向集合中添加数据
		set.add(10);
		set.add(true);
		set.add(10.01);
		set.add("tom");
		set.add("tom");
		//打印集合
		System.out.println(set);
		
		set.add(  new Student(1,"tom")  );
		set.add(  new Student(1,"tom")  );
		
		System.out.println(set);
		//HashSet 怎么判断 对象是否重复.
		//hashCode();
		
		//HashSet方法使用
		Set s2 = new HashSet();
		s2.add("tom");
		s2.add(29);
		
		//查看集合的长度
		int size1 = s2.size();
		s2.add("lisi");
		int size2 = s2.size();
		System.out.println(size1+"-"+size2);
		//判断集合中是否包含 tom字符串
		boolean contains = s2.contains("tom");
		System.out.println(contains);
		//移除
		s2.remove("lisi");
		System.out.println(s2.contains("lisi"));
		//set集合的获取数据，set集合的遍历
		// 迭代器 iterator
		Iterator iterator = s2.iterator();
		//集合在遍历的时候不能进行添加和移除操作，只能获取
		//迭代器 是否有下一个 值
		while(iterator.hasNext()) {
			Object next = iterator.next();
			System.out.println(next);
			//会报错
			//s2.add("lisi");	
		}
		
		/*
		 * HashSet机制<br>
		  * 先 hashCode 再 equals 比较
		 * set.add();
		 * set.remove();
		 * set.size();
		 * set.iterator();
		 * iterator.hasNext();
		 * iterator.next();
		 * */
		
	}
}

hashcode key value之间的关系：

使用key值，通过一个算法算出对应的hashcode值，hashcode取余，找到这个key-value组对应该存放的地方（Object的每个对象都有一个唯一的hashcode；因为hashcode实际上是object的函数，其他类都继承了object，所以所有对象都有hashcode函数）

10.7.6 : TreeSet 可以按照规定排序的集合
            10.7.6.1 : 自然排序(默认) : 实现了Comparable接口 ,重写  compareTo(Object o);
                使用情景: 1,treeSet要排序的是类对象
                      2,这个类必须要实现Comparable, 重写compareTo(Object o)方法。
                效果    ：在使用treeSet 添加该类对象的时候 就会自动调用compareTo()方法进行排序
                      treeSet总是把compareTo()比较得出较小的 放到集合前端。
                     ------------------------------------------------------------------------------------------------
                     JDK类库中实现了Comparable接口的一些类的排序方式： 

                     Byte, Short, Integer, Long, Double, Float     :         按数字大小排序；
                     Character                                     :         按字符的Unicode值的数字大小排序；
                     String                                        :         按字符串中字符的Unicode值排序；
                     ------------------------------------------------------------------------------------------------

            10.7.6.2 : 客户端排序:创建比较器--->实现java.util.Comparator接口,重写compare(Object x, Object y)方法。
                使用:
                    1,写一个比较器(类),实现Comparator接口,重写compart()方法。
                    2,创建该比较器的实例对象。
                    3,将比较器的对象 通过TreeSet的构造器交给TreeSet使用 : eg: new TreeSet(comparator);
                效果:
                    1,利用比较器创建的TreeSet集合在使用add方法添加数据的时候就会调用compart方法排序.
                    2,treeSet 将compart()返回较小的放到前面。

package com.briup.ch10;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

/**
 * 可以排序的set集合<br>
 * java.util.TreeSet
 * */
public class Test3 {
	
	public static void main(String[] args) {
		//声明TreeSet,用来存放Integer类型数据
		Set<Integer> set = new TreeSet<>();
		set.add(10);
		set.add(20);
		set.add(33);
		set.add(82);
		set.add(55);
		System.out.println(set);
		
		//客户端排序 Comparator
		//定义一种排序规则-->交给TreeSet
		Comparator<Integer> comparator = new Comparator<Integer>() {
			/**
			 * 执行set.add(o1);就会触发 比较器compare<br>
			 * treeSet 把 [小] 的数据放到前面
			 * o1 当前添加的数据 treeSet.add(o1);<br>
			 * o2 已经存在set集合中的数据<br>
			 * 使用返回值表示 大小<br>
			 * o1 和 o2<br>
			 * 0  o1==o2<br>  为的就是不保存大小相等的数据
			 * 负数  o1 小于 o2 <br>
			 * 正数  o1 大于 o2
			 * */
			@Override
			public int compare(Integer o1, Integer o2) {
				System.out.println(o1+"---"+o2);
				return 1;
			}
		};
		//set 不能重复， 重复的数据不会保存。
		Set<Integer> treeSet = new TreeSet<Integer>(comparator);
		treeSet.add(10);
		//[10]
		treeSet.add(20);
		/*
		 * compare(o1,o2){
		 *   o1 == 20;
		 *   o2 == 10;
		 * 	  -1  ==>  o1 < o2
		 * }
		 * */ 
		//[20,10]
		treeSet.add(5);
		/*
		 * compare(o1,o2){
		 *   o1 == 5;
		 *   o2 == 10;   //红黑树
		 * 	  -1  ==>  o1 < o2
		 * }
		 * compare(o1,o2){
		 *   o1 == 5;
		 *   o2 == 20;   //红黑树
		 * 	  -1  ==>  o1 < o2
		 * }
		 * */ 
		//[5,20,10]
		treeSet.add(36);
		/*
		 * compare(o1,o2){
		 *   o1 ==  36;
		 *   o2 ==  20;   //红黑树
		 * 	 -1 ==>  o1 < o2
		 * }
		 * 
		 * compare(o1,o2){
		 *   o1 ==  36;
		 *   o2 ==  5;   //红黑树
		 * 	 -1 ==>  o1 < o2
		 * }
		 * 
		 * */
		//[36,5,20,10]
		System.out.println(treeSet);
		
		//根据字符串的长度排序
		Comparator<String> com = new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				int length1 = o1.length();//hello world 11
				int length2 = o2.length();//tom /lisi  3 / 4
				
				if("tom".equals(o1)) {
					//当前添加的数据 是tom
					return -1;
				}
				if("tom".equals(o2)) {
					return 1;
				}
				
				return length2 - length1;
			}
		};
		Set<String> strSet = new TreeSet<>(com);
		strSet.add("lisi");
		strSet.add("tom");
		strSet.add("hello world");
		strSet.add("wangwu");
		strSet.add("zhaoliu");
		System.out.println(strSet);
		
	
	}
	
}

自然排序和客户端排序的区别：

自然排序是类自己，内部重写的，只要增加对象，就会自动调用；客户端排序是重写了一个接口匿名内部类，优先问题:同时存在，调用客户端排序

小问题--的文
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值