Arrays类的概述和方法使用、基本类型包装类、Integer类、String和int类型的相互转换、自动装箱和拆箱
Arrays类的概述和方法使用
A:Arrays类概述
针对数组进行操作的工具类。
提供了排序，查找等功能。
B:成员方法
public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)
案例一：
public class ArrayDemo2 {
public static void main(String[] args) {
int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
//int index=findIndex(arr,40);
//System.out.println(index);
//二分查找的前提：是数组元素必须有序
int index = selectIndex(arr, 80);
System.out.println("索引是" + index);
}
private static int selectIndex(int[] arr, int ele) {
//定义三个索引
int minIndex = 0;
int maxIndex = arr.length - 1;
int centerIndex = (minIndex + maxIndex) / 2;
while (minIndex <= maxIndex) {
if (ele == arr[centerIndex]) {
return centerIndex;
} else if (ele < arr[centerIndex]) {
maxIndex = centerIndex - 1;
} else if (ele > arr[centerIndex]) {
minIndex = centerIndex + 1;
}
//重新计算中间索引
centerIndex = (minIndex + maxIndex) / 2;
}
return -1;
}
private static int findIndex(int[] arr, int ele) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == ele) {
return i;
}
}
return -1;
}
}
案例二：
import java.util.Arrays;
public class MyDemo {
public static void main(String[] args) {
// Arrays 数组工具类，针对数组进行的一些操作
//B:
//成员方法
//public static String toString ( int[] a)
//public static void sort ( int[] a)
//public static int binarySearch ( int[] a, int key)
//static void sort ( int[] a, int fromIndex, int toIndex)
//对指定 int 型数组的指定范围按数字升序进行排序。
int[] arr = {1, 2, 45, 90, 43, 65, 87, 99, 234, 987, 154, 92, 12, 19000, 1768, 2909};
Arrays.sort(arr, 0, arr.length);//只排序一段
System.out.println(Arrays.toString(arr));
//二分查找：元素必须有序
int index = Arrays.binarySearch(arr, 900000);
System.out.println(index);
//String s = showArray(arr);
//System.out.println(s);
}
private static String showArray(int[] arr) {
StringBuilder sb=new StringBuilder("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
sb.append(arr[i]).append("]");
}else{
sb.append(arr[i]).append(",");
}
}
return sb.toString();
}
}
案例三：
import java.util.Arrays;
public class ArrayDemo2 {
public static void main(String[] args) {
//static boolean equals ( int[] a, int[] a2)
//如果两个指定的 int 型数组彼此相等，则返回 true。
int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int[] arr2 = {10, 20, 30, 40, 50, 60, 70, 80, 90, 10};
boolean b = Arrays.equals(arr, arr2);
System.out.println(b);
//static void fill ( int[] a, int val)
//将指定的 int 值分配给指定 int 型数组的每个元素。
Arrays.fill(arr, 222);
//static void fill ( int[] a, int fromIndex, int toIndex, int val)
//将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
System.out.println(Arrays.toString(arr));
}
}
基本类型包装类的概述
A: 需求:
a:将100转换成二进制 , 八进制 , 十六进制
b:判断一个数是否在int的范围内
B:为什么会有基本类型包装类
为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.
C:常用操作: 常用的操作之一：用于基本数据类型与字符串之间的转换。
D:基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
案例
public class MyDemo {
public static void main(String[] args) {
//A:
//需求:
//a:
//将100转换成二进制, 八进制, 十六进制
//b:
//判断一个数是否在int的范围内
// int num=100;
// <= 100000000<=
//Java为了我们更方便的去操作基本数据类型，给我们提供与之对应的包装类型
//基本类型 包装类型
//byte -----------------------Byte
//short------------------------Short
//int--------------------------Integer
//long---------------------------Long
//float------------------------ Float
//double----------------------- Double
//char ------------------------Character
//boolean -----------------------Boolean
int num=100;
String string = Integer.toBinaryString(num);
String string1 = Integer.toOctalString(num);
String string2 = Integer.toHexString(num);
System.out.println(string);
System.out.println(string1);
System.out.println(string2);
// System.out.println(new Object().toString());
//public String toString () {
// return getClass().getName() + "@" + Integer.toHexString(hashCode());
//}
boolean b= 100000>=Integer.MIN_VALUE&& 100000<=Integer.MAX_VALUE?true:false;
System.out.println(b);
}
}
Integer类的概述和构造方法
A:Integer类概述
通过JDK提供的API，查看Integer类的说明
Integer 类在对象中包装了一个基本类型 int 的值,
该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
还提供了处理 int 类型时非常有用的其他一些常量和方法
B:构造方法
public Integer(int value)
public Integer(String s)
String和int类型的相互转换
A:int – String
a:和""进行拼接
b:public static String valueOf(int i)
c:int – Integer – String
d:public static String toString(int i)
B:String – int
a:String – Integer – intValue();
b:public static int parseInt(String s)
C:案例演示
案例：
使用Integer转换int–String及String–int
- int i1 = Integer.parseInt(str2);
- int i = integer.intValue();//将包装类型，转换成他所对应的基本类型
public class MyTest {
public static void main(String[] args) {
//A:
//int --String
int num=100;
String str=num+"";
String.valueOf(num);
String s = new Integer(num).toString();
//String -----int
String str2="50";
//方式1
Integer integer = new Integer(str2);
int i = integer.intValue();//将包装类型，转换成他所对应的基本类型
System.out.println(i+1);
//方式2
int i1 = Integer.parseInt(str2);
System.out.println(i1);
}
}
JDK5的新特性自动装箱和拆箱
A:JDK5的新特性
自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
B:案例演示
JDK5的新特性自动装箱和拆箱
Integer ii = 100;
ii += 200;
C:注意事项
在使用时，Integer x = null;代码就会出现NullPointerException。
建议先判断是否为null，然后再使用。
案例：
public class MyTest {
public static void main(String[] args) {
Integer ii = 100;//自动装箱
ii += 200;//自动拆箱。自动装箱
Integer integer = new Integer(1000);
int i = integer.intValue(); //手动拆箱
Integer integer1 = Integer.valueOf(100);//手动装箱
Integer integer2 = Integer.valueOf("10000");
}
}
案例二：
public class MyTest2 {
public static void main(String[] args) {
//JDK1.5之后，引入的自动拆装箱
//自动拆箱：将包装类型自动转换成他所对应的基本类型
//自动装箱：将基本类型自动转换成他所对应的包装类型
Integer num=new Integer(100);
Integer num2=100;//自动装箱
int num3=50;
int i = num.intValue();//手动拆箱
int r=num+num3;
System.out.println(r);
}
}
案例三：
public class MyTest {
public static void main(String[] args) {
//String toString ()
//返回一个表示该 Integer 值的 String 对象。
//static String toString ( int i)
//返回一个表示指定整数的 String 对象。
//int intValue ()
//以 int 类型返回该 Integer 的值。
//static int parseInt (String s)
//将字符串参数作为有符号的十进制整数进行解析。
//static Integer valueOf ( int i)
//返回一个表示指定的 int 值的 Integer 实例。
//static Integer valueOf (String s)
//返回保存指定的 String 的值的 Integer 对象。
String string = Integer.
toString(100);
String string1 = new Integer(100).toString();
}
}
案例四：
public class MyTest2 {
public static void main(String[] args) {
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//false
//Integer重写了父类的equals方法，比较的是值是否相等
System.out.println(i1.equals(i2));//true
System.out.println("-----------");
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//false
System.out.println(i3.equals(i4));//true
System.out.println("-----------");
//这个值，超过了一个字节的范围，回去重新new一个Integer对象
Integer i5 = 128;
Integer i6 = 128;
System.out.println(i5 == i6);//false
System.out.println(i5.equals(i6));//true
System.out.println("-----------");
// Integer integer = Integer.valueOf(127);
//没有超过一个字节 会从缓存里面取出一个对象
Integer i7 = 127;
Integer i8 = 127;
System.out.println(i7 == i8);//true
System.out.println(i7.equals(i8));//true
Integer a = new Integer(127);
Integer b = 127;
System.out.println(a == b);
Integer.valueOf(100);
}
}
注意：Integer赋值超过了127范围会重新new对象所以两次赋值地址值不同；如果在-128到127则会直接取出引用其地址值不用重新new对象。
没有超过一个字节的范围 因为在方法区中存在一个 字节常量池 范围-128—127
案例四：
public class MyTest4 {
public static void main(String[] args) {
boolean b=true;
Boolean aBoolean = new Boolean(b);
String str="false";
Boolean aBoolean1 = new Boolean(str);
boolean b1 = aBoolean.booleanValue();
Boolean aBoolean2 = Boolean.valueOf(true);
String str2 = "false";
boolean b2 = Boolean.parseBoolean(str2);
}
}
案例五：
import java.time.LocalDate;
c class MyTest5 {
public static void main(String[] args) {
long num=1L;
Long aLong = Long.valueOf(num);
long l = aLong.longValue();
long l1 = Long.parseLong("100000000");
}
}
案例六：
public class MyTest6 {
public static void main(String[] args) {
char ch='a';
Character character = new Character(ch);
char c = character.charValue();
//static boolean isLetter ( char ch)
//确定指定字符是否为字母。
//
//static boolean isLowerCase ( char ch)
//确定指定字符是否为小写字母。
//
//static boolean isUpperCase ( char ch)
//确定指定字符是否为大写字母。
//
//static boolean isDigit ( char ch)
//确定指定字符是否为数字。
//
//static boolean isSpaceChar ( char ch)
//确定指定字符是否为 Unicode 空白字符。
boolean spaceChar = Character.isSpaceChar(' ');
System.out.println(spaceChar);
}
}