javaseday16(基本数据类型的包装 | 集合的基本方法)

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一:用于基本数据类型和字符串之间的转换

例如 Integer 的parseInt方法 intValue 方法

负数最高位为1 是因为取反

/*
* 基本数据类型对象包装类
* 为了方便操作基本数据类型值 将其封装成了对象 在对象中定义了属性和行为丰富了该数据的操作
* 用于描述该对象的类就称为基本数据类型对象包装类
*
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* char Character
* boolean Boolean
*
* 该包装对象主要用于基本类型和字符串之间的转换
*
* 基本类型-->字符串
* 1、基本类型+""
* 2、用String 类中的静态方法valueOf(基本类型数值)；
* 3、用Integer的静态方法valueOf();
* 字符串-->基本类型
* 1、使用包装类的静态方法 xxx parseXxx("xxx类型的字符串")；***最常用
* int parseInt("intstring");
* boolean parseBoolean("booleanstring");
* 只有Character 没有parse方法
* 2、如果字符串被Integer进行对象的封装
* 可使用另一个非静态方法intValue();
* 将一个Integer对象转成基本数据类型值
*
*/
System.out.println(Integer.toBinaryString(-6));
int num =4 ;
Integer a = new Integer(num); //包装成对象


int x = Integer.parseInt("123");//因为没有访问对象的特有数据所以定义成静态直接类名调用 抛出了异常但是是运行时异常
//声明是为了让你去处理 而且可处理 必须得传数字格式的字符串 不然运行时报异常
System.out.println(x);
/*
* 整数具备不同的进制体现
* 十进制-->其他进制
*
* 其他进制-->十进制
* jdk 1.5 之前要Integer i = new Integer(4); 
* 之后可以 Integer i = 4;自动装箱 简化书写 int 怎么操作Integer就能怎么玩 但会有健壮性问题 比如 赋予null
* -128~127(含) 自动装箱的如果是一个字节 那么数据会被共享 不会重新开空间
* 
* 
*/
System.out.println(Integer.toString(60,2));
System.out.println(Integer.toBinaryString(60));
System.out.println(Integer.parseInt("3c",16)); //转化成10进制的按照后一个参数的进制大小
Integer a1 = new Integer(3);
Integer a2 = new Integer("3");


System.out.println(a1==a2);//必然不同 new了
System.out.println(a1.equals(a2)); //比较大小


System.out.println(a1.compareTo(a2));//不再直接减 返回1 -1 0 知道比较结果就行不然可能太大

Integer x2 = 127;
Integer x3= 127;
System.out.println(x2==x3);//true 在-128~127范围内

import java.util.Arrays;


/*
 * 对一个字符串中的数值进行从小到大的排序
 * "10 50 54 20 10 -4 51"
 *
 * 思路
 * 1、排序
 * 2、如何获取到这个字符串中的这些需要排序的数值
 * 发现这个字符串起始都是用空格来对数值进行分隔
 * 所以想到用字符串对象的切割方法将大串变成多个小串
 * 3、数值最终变成小字符串 怎么变成int数  因为 字符串中"" 9比20大 先判断第一个大小
 * 字符串-->基本类型可以使用包装类
 *
 */
public class Test02 {
private static final String SPACE_SEPERATOR = " ";//ctrl+shift+x 变大写 +y变小写
public static void main(String[] args) {
String numStr = "10 50 54 20 10 -4 51";
System.out.println(numStr);
numStr = sortString(numStr);
System.out.println(numStr);
}


private static String sortString(String numStr) {
//1、将字符串变成字符串数组
String[] str_arr = stringToArray(numStr);
//2、将字符串数组变成int数组
int[] num_arr = toIntArray(str_arr);
//3、对int数组排序
mySortArray(num_arr);
//4、将排序后的int数组变成字符串
String temp = arrayToString(num_arr);


return temp;
}


private static String arrayToString(int[] num_arr) {
StringBuilder sb = new StringBuilder();


for (int i = 0; i < num_arr.length; i++) {
if(i!=num_arr.length-1){
sb.append(num_arr[i]+SPACE_SEPERATOR);
}else
sb.append(num_arr[i]);
}
return sb.toString();
}


private static void mySortArray(int[] num_arr) {
Arrays.sort(num_arr);


}


private static int[] toIntArray(String[] str_arr) {
int[] arr = new int[str_arr.length];
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(str_arr[i]);
}
return arr;
}




private static String[] stringToArray(String numStr) {
String[] str_arr = numStr.split(SPACE_SEPERATOR);


return str_arr;
}
}

new("李四",22);  李四 是属性值 name 是属性

import java.util.ArrayList;
import java.util.Collection;


public class Test03 {
/*
* 容器都有其特定的结构 部分有共性的结构 在collection
* 集合经常使用
* 为什么会有集合类
* 面向对象语言对事物的体现都是以对象的形式 所以为来方便对多个对象的操作 就对对象进行存储 集合就是存储对象最常用的一种方式
* 数组和集合类同是容器有什么不同
* 数组虽然也可以存储对象 但是长度是固定的 集合长度是可变的 数组中可以存储基本数据类型 集合只能存储对象
* 集合类的特点
* 集合只用于存储对象 集合长度是可变的 集合可以存储不同类型的对象
* 集合类的由来
*  对象用于封装特有数据 对象多了需要存储 如果对象的个数不确定就使用集合容器进行存储
* 集合特点
* 1、用于存储对象的容器
*  2、集合的长度是可变的
*  3、集合中不可以存储基本数据类型
* 集合容器因为内部的数据结构不同 有多种具体容器
* 不断的向上抽取 形成了集合框架
* 框架的顶层就是Collection
* Collection常见方法
* 1、增加
* boolean add(Object obj); 删除一个
* boolean addAll(Collection coll);
* 2、删除
*  boolean remove(Object obj);
*  boolean removeAll(Collection coll);删除一堆
*  void clear(); 删除所有元素
* 3、 判断
* boolean contains(Object obj);
*  boolean containsAll(Collection coll)
* boolean isEmpty() 判断集合中是否有元素
* 4、获取
*  int size();  获取长度
*  iterator iterator() 用于取出元素的方式 迭代器 返回迭代器对象
* 5、其他
* boolean retainAll(Collection coll) 取交集
*  Object[] toArray() 将集合转成数组
* StringBuilder StringBuffer 最终必须转成字符串才能使用
*
*
*/
public static void main(String[] args) {
Collection coll = new ArrayList();


Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
// show(c1,c2);
// show(coll);

}
private static void show(Collection c1, Collection c2) {
//给c1添加元素
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
c1.add("abc4");


//给c2添加元素
c2.add("abc2");
c2.add("abc6");
c2.add("abc7");


System.out.println("c1"+c1);
System.out.println("c2"+c2);


//addAll 全都加进去
c1.addAll(c2);


System.out.println("c1"+c1);


//removeAll 将两个集合中的相同元素从调用removeAll的集合中删除
boolean b = c1.removeAll(c2);


//containsAll


boolean b1 = c1.containsAll(c2);
System.out.println(b1);


//retainAll 取交集 保留和指定集合相同的元素 删除不同的元素 和removeAll功能相反
boolean b2 = c1.retainAll(c2);
System.out.println(c1);
}
public static void show(Collection coll){//1.5的新技术 黄色感叹号  有安全性判断
//1、添加元素 add
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
System.out.println(coll);//整个字符串  不算取出来


//2、删除元素 remove
coll.remove("abc2"); //会改变集合的长度


System.out.println(coll);


//3、是否包含元素
System.out.println(coll.contains("abc1"));
System.out.println(coll.contains("abc2"));


//清空集合
coll.clear();
System.out.println(coll);


}
}