API常用类

最新推荐文章于 2024-01-19 08:00:00 发布

refuse-debug

最新推荐文章于 2024-01-19 08:00:00 发布

阅读量1.3k

点赞数 1

分类专栏： JAVA SE入门基础文章标签： java

本文链接：https://blog.csdn.net/refuse_debug/article/details/104135716

版权

JAVA SE入门基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的Object类，包括其hashCode(), getClass(), toString()等方法；Scanner类的键盘输入操作及方法；String类的概念、构造方法和常用功能；StringBuffer线程安全的字符串操作；以及Arrays类的排序和查找方法。同时，文章还讨论了Integer和Character这两个包装类的基本用法和转换方法。" 1657385,20308,使用jython将python程序转换为java jar包,"['python', 'java', 'jython', '编译转换', 'jar']

摘要由CSDN通过智能技术生成

文章目录

1、Object类

概述：是类层次结构的根类。每个类都用Object 作为超类。每个类都直接间接继承Object类

成员方法

public int hashCode()

返回该对象的哈希码值。哈希值是根据哈希算法计算出来的一个值。这个值和地址值有关，但是不是实际地址值。，可以理解为地址值。

public class StudentText {
	public static void main(String[] args) {
		Student s1 =  new Student();
		System.out.println(s1.hashCode());
		
		Student s2 =  new Student();
		System.out.println(s2.hashCode());
	}

}
public class Student extends Object{

}
输出：
2018699554
1311053135

public final Class getClass()

返回此Object 的运行时类Class类的方法

public String getName() 以String 的形式返回此Class 对象所表示的实体。

public class StudentDemo {
	public static void main(String[] args) {
		Student s = new Student();
		System.out.println(s.hashCode());
		System.out.println(s.getClass().getName());//全路径的类名名称
	}

}
public class Student {
	private String name;
	private int age;

	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

}
输出;
2018699554
cqupt.cn02.Student

public String toString()

返回该对象的字符串表示等价于

get Class().getName() + ‘@’ + Interger.toHexString(hashCode())

Integer类下的一个静态方法：

public static String toHexString(int i): 把一个整数转成一个十六进制表示

public class StuudentDemo2 {
	public static void main(String[] args) {
		Student s1 = new Student();
		System.out.println(s1.hashCode());
		System.out.println(s1.getClass().getName());
		System.out.println("-----------------");
		System.out.println(s1.toString());
		System.out.println(s1);//默认

	}
}

class Student {
	private String name;
	private int age;

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public Student() {
		super();
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
//建议重写toString方法
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
}
/*输出：
2018699554
cqupt_02.Student
-----------------
没重写 ：cqupt_02.Student@7852e922(hashCode的十六进制)
Student [name=null, age=0]
Student [name=null, age=0]
*/

public boolean equals(Object obj)

指示其他某个对象是否与此对象“相等”。

默认情况下比较的是地址值,意义不大，一般情况需要重写比较的是成员变量的值。

String类已经重写了。

重写equals

在这里插入图片描述

public class StudentDemo {
	public static void main(String[] args) {
		Student s1 = new Student("林青霞",27);
		Student s2 = new Student("林青霞",27);
		System.out.println(s1==s2);//false
		Student s3 = s1;
		System.out.println(s1 == s3);//true
		System.out.println("--------------");
		
		System.out.println(s1.equals(s2));
	}
}

class Student {
	private String name;
	private int age;

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public Student() {
		super();
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}
/*输出：
false
true
--------------
false
*/

protected void finalize()

当垃圾回收器确定确定不存在该对象更多引用时，由对象的垃圾回收器调用该方法。用于垃圾回收，什么时候回收不确定

protected Object clone()

创建并返回此对象的一个副本

public class StudentDemo {
	public static void main(String[] args) throws CloneNotSupportedException {
		// 创建学生对象
		Student s1 = new Student();
		s1.setAge(20);
		s1.setName("林青霞");
		// 克隆学生对象
		Object obj = s1.clone();
		Student s2 = (Student) obj;
	
		
		System.out.println(s1.getAge() + "=======" + s1.getName());
		System.out.println(s2.getAge() + "......." + s2.getName());
	}
}

// 标记接口
class Student implements Cloneable {
	private String name;
	private int age;

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public Student() {
		super();
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	//重写
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}
}
/*输出
20=======林青霞
20.......林青霞
*/

2、Scanner类

作用

用于键盘录入。

步骤

1、导包。2、创建对象。3、调方法

Scanner sc = new Scanner(System.in);
int xxx = sc.nextXxx

静态字段

public start final InputStream in

System.in (是一个 InputStream类型的对象)

InputStream is = System.in

构造方法

Scanner ( InputStream sourse)

所以创建对象格式为：Scanner sc = new Scanner(System.in);

方法

1、public boolean hasNextXxx()

判断是否是某种类型数据

public class ScannerDemo {
	public static void main(String[] args) {
		//创建对象
		Scanner sc = new Scanner(System.in);
		if(sc.hasNextInt()) {
			int x = sc.nextInt();
			System.out.println(x);
		}else {
			System.out.println("你发输入的数据有误");
		}

	}
}
/*输出
阿萨德
你发输入的数据有误
*/

2、public xxx nextXxx()

获取该元素

3、String类

概念

字符串：有多个字符组成的一串数据，可看成字符数组。

构造方法

1.public String() 空构造
2.public String(byte[] bytes) 把字节数组转成字符串
3.public String(byte[] bytes,int index,int length) 把字节数组的一部分转成字符串
4.public String(char[] value) 把字符数组转成字符串
5.public String(char[] value，int index,int count) 把字符数组的一部分转成字符串
6.public String(String original) 把字符串常量值转成字符串

package com.xian.fang;

public class Demo3_StringCon {
	public static void main(String[] args) {
		
		String s1 = new String();						//空参构造，没有任何输出
		System.out.println(s1);
		
		byte[] arr1 = {97,98,99};						//字节数组作为参数，解码字节数组，把字节数组转换成字符串
		String s2 = new String(arr1);
		System.out.println(s2);
		
		byte[] arr2 = {97,98,99,100,101,102};			//把字节数组的一部分转换成字符串
		String s3 = new String(arr2,2,3);
		System.out.println(s3);
		
		char[] arr4 = {'a','b','c'};					//把字符数组转换成字符串
		String s4 = new String(arr4);
		System.out.println(s4);
		
		char[] arr5 = {'a','b','c','d','e'};			//把字符数组的一部分转换成字符串
		String s5 = new String(arr5, 3, 2);
		System.out.println(s5);
        
    String s6=new String("KobeBryant");
　　　　System.out.println(s6);
	}
}

特点

一旦被赋值就不能被改变。（值不变）

public class StringDemo {
	public static void main(String[] args) {
		String s = "hello";
		s +="world";
		System.out.println(s);
	}

}
//输出：helloworld

内存图解：
在这里插入图片描述

区别

	//创建两个对象
	String s1 = new String("hello");
	//创建一个对象
	String s2 = "hello";
	
	System.out.println(s1 == s2);//false
	System.out.println(s1.equals(s2));//true
}
}

S1赋值过程：

在这里插入图片描述

S2赋值过程：

[外链图片转存失败,源站可能有防盗链机制,建议将

例题：

public class StringDemo2 {
public static void main(String[] args) {
	
	String s1 = "hello";
	String s2 = "world";
	String s3 = "helloworld";
	
	System.out.println(s3 ==s1+ s2);//false
	
	System.out.println(s3.equals(s1+s2));//true
	
	System.out.println(s3 =="hello"+"world");//true
	
	System.out.println(s3.equals("helloworld"));//true
}
}

总结：

字符串如果是变量相加，想开空间再拼接。

字符串如果是常量相加，先加，再去常量池找，有返回，没有创建并返回。

判断功能

字符串的判断功能
A：字符串的长度：public int length()：返回此字符串的长度

B：字符串的判断功能：

（1）boolean equals(Object obj)

    比较字符串的内容是否相同，区分大小写

（2）boolean equalsIgnoreCase(String str)

    比较字符串的内容是否相同，不区分大小写

（3）boolean contains(String str)

    判断大字符串中是否包含小字符串

（4）boolean startsWith(String str)

    判断字符串是否以某个指定的字符串开头

（5）boolean endsWith(String str)

    判断字符串是否以某个指定的字符串结尾

（6）boolean isEmpty( )

    判断字符串是否为空

代码示例：

public static void main(String[] args) {
		String s1 = "helloworld";
		String s2 = "helloworld";
		String s3 = "HelloWorld";
 
		// boolean equals(Object obj)
		// 比较字符串的内容是否相同，区分大小写
		System.out.println("equals:" + s1.equals(s2));//true
		System.out.println("equals:" + s1.equals(s3));//false
		System.out.println("---------------");
 
		// boolean equalsIgnoreCase(String str)
		// 比较字符串的内容是否相同，不区分大小写
		System.out.println("equalsIgnoreCase:" + s1.equalsIgnoreCase(s2));//true
		System.out.println("equalsIgnoreCase:" + s1.equalsIgnoreCase(s3));//true
		System.out.println("---------------");
 
		// boolean contains(String str)
		// 判断大字符串中是否包含小字符串
		System.out.println("contains:" + s1.contains("hello"));//true
		System.out.println("contains:" + s1.contains("hw"));//false
		System.out.println("---------------");
 
		// boolean startsWith(String str)
		// 判断字符串是否以某个指定的字符串开头
		System.out.println("startsWith:" + s1.startsWith("hello"));//true
		System.out.println("startsWith:" + s1.startsWith("h"));//true
		System.out.println("startsWith:" + s1.startsWith("e"));//false
		System.out.println("---------------");
 
		// boolean endsWith(String str)
		// 判断字符串是否以某个指定的字符串结尾
		System.out.println("endsWith:" + s1.endsWith("world"));//true
		System.out.println("endsWith:" + s1.endsWith("ld"));//true
		System.out.println("endsWith:" + s1.endsWith("l"));//false
		System.out.println("---------------");
 
		// boolean isEmpty()
		// 判断字符串是否为空
		System.out.println("isEmpty:" + s1.isEmpty());//false
		System.out.println("isEmpty:" + s2.isEmpty());//false
 
		String s4 = "";
		String s5 = null;
		System.out.println("isEmpty:" + s4.isEmpty());//true
		//java.lang.NullPointerException:空指针异常
		//System.out.println("isEmpty:" + s5.isEmpty());//报错误！
		System.out.println("---------------");
	}
 
}

获取功能

（1）int length()

    获取字符串的长度，即字符串中字符的个数。

（2）char charAt(int index)

    获取指定索引位置上的字符。

（3）int indexOf(int ch)

    获取指定字符在此字符串中第一次出现的索引。注意：这里用的是int，不是char，原因是'a'和97都可以作为实参传入。

（4）int indexOf(String str)

    获取指定字符串在此字符串中第一次出现的索引。

（5）int indexOf(int ch,int fromIndex)

    获取指定字符在此字符串中指定位置后第一次出现的索引。

（6）int indexOf(String str,int fromIndex)

    获取指定字符串在此字符串中指定位置后第一次出现的索引。

（7）String substring(int start)

    从指定位置截取子字符串，默认是截取到末尾。（包含start位置）

（8）String substring(int start,int end)

    从指定位置开始到指定位置结束截取子字符串。（包start不包end）

代码示例：

public class StringDemo {
	public static void main(String[] args) {
		// int length()
		// 获取字符串的长度，即字符串中字符的个数。
		String s="helloworld";
		System.out.println("length():"+s.length());//10
		System.out.println("--------------");
		
		// char charAt(int index)
		// 获取指定索引位置上的字符。
		System.out.println("charAt:"+s.charAt(0));//h
		System.out.println("charAt:"+s.charAt(9));//d
		System.out.println("--------------");
		
		// int indexOf(int ch)
		// 获取指定字符在此字符串中第一次出现的索引。注意：这里用的是int，不是char，
		// 原因是'a'和97都可以作为实参传入。
		System.out.println("indexOf:"+s.indexOf('h'));//0
		System.out.println("indexOf:"+s.indexOf('d'));//9
		System.out.println("--------------");
		
		// int indexOf(String str)
		// 获取指定字符串在此字符串中第一次出现的索引。
		System.out.println("indexOf:"+s.indexOf("owo"));//4
		System.out.println("indexOf:"+s.indexOf("ld"));//8
		System.out.println("--------------");
		
		// int indexOf(int ch,int fromIndex)
		// 获取指定字符在此字符串中指定位置后第一次出现的索引。
		// int indexOf(String str,int fromIndex)
		// 获取指定字符串在此字符串中指定位置后第一次出现的索引。
		System.out.println("indexOf:"+s.indexOf('l',4));//8
		System.out.println("indexOf:"+s.indexOf('l',40));//-1
		System.out.println("--------------");
		
		// String substring(int start)
		// 从指定位置截取子字符串，默认是截取到末尾。（包含start位置）
		System.out.println("substring:"+s.substring(4));//oworld
		System.out.println("substring:"+s.substring(0));//helloworld
		
		// String substring(int start,int end)
		// 从指定位置开始到指定位置结束截取子字符串。（包start不包end）
		System.out.println("substring:"+s.substring(4,8));//owor
		System.out.println("substring:"+s.substring(0,s.length()));//helloworld
		
	}
}

转换功能

（1）byte[ ] getBytes( )

    把字符串转换为字节数组。

（2）char[ ] toCharArray( )

    把字符串转换为字符数组。

（3）static String valueOf(char[ ] chs)

    把字符数组转成字符串。

（4）static String valueOf(int i)

    把int类型的数据转成字符串。

     注意：String类的valueOf方法可以把任意类型的数据转成字符串。

（5）String toLowerCase( )

    把字符串转成小写。

（7）String toUpperCase( )

    把字符串转成大写。

（8）String concat(String str)

    把字符串拼接。用 + 也可以。

代码示例：

public class StringDemo4 {
	public static void main(String[] args) {
		// 定义一个字符串对象
		String s = "JavaSE";
 
		// byte[] getBytes():把字符串转换为字节数组。
		byte[] bys = s.getBytes();
		for (int x = 0; x < bys.length; x++) {
			System.out.println(bys[x]);
		}
		System.out.println("----------------");
 
		// char[] toCharArray():把字符串转换为字符数组。
		char[] chs = s.toCharArray();
		for (int x = 0; x < chs.length; x++) {
			System.out.println(chs[x]);
		}
		System.out.println("----------------");
 
		// static String valueOf(char[] chs):把字符数组转成字符串。
		String ss = String.valueOf(chs);
		System.out.println(ss);
		System.out.println("----------------");
 
		// static String valueOf(int i):把int类型的数据转成字符串。
		int i = 100;
		String sss = String.valueOf(i);
		System.out.println(sss);
		System.out.println("----------------");
 
		// String toLowerCase():把字符串转成小写。
		System.out.println("toLowerCase:" + s.toLowerCase());
		System.out.println("s:" + s);
		System.out.println("----------------");
		
		// String toUpperCase():把字符串转成大写。
		System.out.println("toUpperCase:" + s.toUpperCase());
		System.out.println("s:" + s);
		System.out.println("----------------");
 
		// String concat(String str):把字符串拼接。
		String s1 = "JavaSE";
		String s2 = "JavaEE";
		String s3 = s1 + s2;
		String s4 = s1.concat(s2);
		System.out.println("s3:"+s3);
		System.out.println("s4:"+s4);
	}
}

其他功能

（1）替换功能：

    String replace(char old,char new)

    String replace(String old,String new)

（2）去除字符串两端的空格

    String trim()

（3）按字典顺序比较两个字符串

    int compareTo(String str)

    int compareToIgnoreCase(String str)

代码示例：

public class StringDemo6 {
	public static void main(String[] args) {
		// 替换功能
		String s1 = "helloworld";
		String s2 = s1.replace('l', 'k');
		String s3 = s1.replace("owo", "ak47");
		System.out.println("s1:" + s1);
		System.out.println("s2:" + s2);
		System.out.println("s3:" + s3);
		System.out.println("---------------");
 
		// 去除字符串两端的空格
		String s4 = " hello world  ";
		String s5 = s4.trim();
		System.out.println("s4:" + s4 + "---");
		System.out.println("s5:" + s5 + "---");
 
		// 按字典顺序比较两个字符串
		String s6 = "hello";
		String s7 = "hello";
		String s8 = "abc";
		String s9 = "xyz";
		System.out.println(s6.compareTo(s7));// 0
		System.out.println(s6.compareTo(s8));// 7
		System.out.println(s6.compareTo(s9));// -16
	}
}

4、StringBuffer类

概述

线程安全的可变字符序列。长度内容可改（String不能改）

如果使用前者使用字符串拼接不会浪费太多资源。

线程安全

安全-------同步-------数据安全

不安全--------不同步------效率高------数据不安全

安全和效率永远困扰，一般选一个

安全：医院网站、银行网站（慢）

效率：新闻网站、论坛网站（快）

区别

StringBuffer与String

前者长度内容可变，后者不可变

如果用前者不会老肥太多资源

构造方法

StringBuffer：

public StringBuffer() 无参构造（）初始容量16

public StringBuffer(int capacity) 指定容量的字符串缓冲区对象

public StringBuffer(String str) 指定字符串内容的字符串缓冲区对象 16+xxx

成员方法：

public int capacity() 返回当前容量（理论值）

public int length() 返回当前长度（实际值）

添加功能

append(添加)

public StringBuffer append(String str):

可以把任何类型添加到字符串缓冲区里面,并且返回字符串缓冲区本身.

public class StringBufferDemo {
	public static void main(String[] args) {
		// 创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		// public StringBuffer append(String str)
		StringBuffer sb2 = sb.append("hellow");
		//没有重新开空间，返回的是本身，直接将"hellow" 装入之前的容器
		System.out.println("sb:" + sb);//hellow
		System.out.println("sb2:" + sb2);//hellow
		System.out.println(sb == sb2); //TRUE,没有重新开空间
        //一步一步添加数据
        //sb.append(23);
        //sb.append("asda");
        //sb.append(true);
        //sb.append(2.3);
	}
}

insert（插入）

public StringBuffer insert(int offset,String str):

在指定位置把任意类型的数据插入到字符串缓冲区里面，返回的是本身

删除功能

deleteCharAt （int index）

删除指定位置字符并返回本身

		// 创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		//添加功能
		sb.append("hello").append("world").append("java");
		System.out.println("sb:" + sb);
		
		//删除e这个字符
		sb.deleteCharAt(1);
		System.out.println("sb:" + sb);
		
		//删除第一个l这个字符
		sb.deleteCharAt(1);
		System.out.println("sb:" + sb);
输出：
sb:helloworldjava
sb:hlloworldjava
sb:hloworldjava

delete(int start,int end)

	sb.append("hello").append("world").append("java");
		System.out.println("sb:" + sb);
		
		//删除world
		sb.delete(5, 10);
		System.out.println("sb:" + sb);
输出：
sb:hellojava

替换功能

replace

public StringBuffer replace(int start,init end,String str)

包左不包右

		StringBuffer sb = new StringBuffer();
		//添加功能
sb.append("hello").append("world").append("java");
		System.out.println("sb:" + sb);
     //把word替换为节日快乐
		sb.replace(5, 10, "节日快乐");
		System.out.println(sb);
输出：
hello节日快乐java

翻转功能

reverse

	// 创建字符串缓冲区对象
	StringBuffer sb = new StringBuffer();
	//添加功能
	sb.append("hello").append("world").append("java");
	
	sb.reverse();
	
	System.out.println("sb:" + sb);
输出：
sb:avajdlrowolleh

之前返回的都是本身 StringBuffer

截取功能

substring、

public String substring(int start)

public String substring(int start,int end)

因为是String 返回的容器会变

		// 创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		// 添加功能
		sb.append("hello").append("world").append("java");
		String s = sb.substring(5);
		System.out.println(s);
		System.out.println(sb);
		
		String ss = sb.substring(5,10);
		System.out.println(ss);
		System.out.println(sb);
输出;
worldjava
helloworldjava
world
helloworldjava

String和StringBuffer相互转换

String ------> StringBuffer

方法1:构造方法

String s = "hello";
StringBuffer  sb = new StringBuffer(s)

方法2：通过append()方法

StringBuffer  sb = new StringBuffer();
    sb.append(s);

StringBuffer------> String

方式一：构造方法

StringBuffer  s = new StringBuffer("java");
String str2 = String(s);

方式二：通过toString()

StringBuffer  s = new StringBuffer("java");
String str2 = s.toString()；

面试题：

一、String , StringBuffer,StringBuilder的区别

A，String 内容是不可变的，而StringBuffer,StringBuilder都是内容可变的

B、StringBuffer是同步的，数据安全效率低，StringBuilder是不同步的，数据不安全效率高。

StringBuffer与数组的区别

二者都可以看成一个容器

但是，StringBuffer数据最终是一个字符串数据。而数组放置多种数据，必须是同一类型的。

形式参数：

A: 基本类型：形式参数的改变不影响实际参数

B: 引用类型：形式参数的改变直接影响实际参数

注意：String作为参数传递，效果和基本类型作为参数传递是一样的。StringBuffer直接赋值不变，做操作调方法会变。

public class StringBufferDemo {
	public static void main(String[] args) {
		String s1 = "hello";
		String s2 = "world";

		System.out.println(s1 + "........" + s2);
		change(s1, s2);
		System.out.println(s1 + "........." + s2);

		StringBuffer sb1 = new StringBuffer("hello");
		StringBuffer sb2 = new StringBuffer("world");
		System.out.println(sb1 + "......." + sb2);
		change(sb1, sb2);
		System.out.println(sb1 + "......." + sb2);
	}

	private static void change(StringBuffer sb1, StringBuffer sb2) {
		sb1 = sb2;
		sb2.append(sb1);

	}

	private static void change(String s1, String s2) {
		s1 = s2;
		s2 = s1 + s2;

	}
}
/*输出：
hello........world
hello.........world
hello.......world
hello.......worldworld*/

5、Arrays类

概述

1、针对数组进行操作的类

2、提供了排序查找等功能

成员方法

1、toString

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。

public static void main(String[] args) {
  // 定义int 数组
  int[] arr  =  {2,34,35,4,657,8,69,9};
  // 打印数组,输出地址值
  System.out.println(arr); // [I@2ac1fdc4
  // 数组内容转为字符串
  String s = Arrays.toString(arr);
  // 打印字符串,输出内容
  System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9]
}

2、sort

public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

public static void main(String[] args) {
  // 定义int 数组
  int[] arr  =  {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
  System.out.println("排序前:"+ Arrays.toString(arr)); // 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6,
2]
  // 升序排序
  Arrays.sort(arr);
  System.out.println("排序后:"+ Arrays.toString(arr));// 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46,
48]
}

3、binarySearch

public static int binarySearch(int [] a , int key)

用二分法查找数组中的某个元素。该方法和 sort 方法一样，适用于各种基本数据类型以及对象。

注意：二分法是对以及有序的数组进行查找（比如先用Arrays.sort()进行排序，然后调用此方法进行查找）。找到元素返回下标，没有则返回 -1

eg1:

int []arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 20));

结果是：1
分析：能找到该元素，返回下标为1（0开始）
eg2:

int []arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 35));

结果是：-4
分析：找不到元素，返回-x，从-1开始数，如题，返回-4
eg3:

int []arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 0,3,30));

结果是：2
分析：从0到3位（不包括）找30，找到了，在第2位，返回2
eg4:

int []arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 0,3,40));

结果是：-4
分析：从0到3位（不包括）找40，找不到，从-1开始数，返回-4

6、包装类

概述：

为了对基本数据类型进行更多操作，Java就针对每一种基本类型提供了对应的类类型。

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

常见操作：用于基本数据类型与字符串之间的转换

Integer

构造方法：

public Integer (int value)
public Integer (String s)

public class IntegerDemo {
public static void main(String[] args) {
	//方式一
	int i = 100;
	Integer ii = new Integer(i);
	System.out.println(ii);
	//方式二
	String s ="100";//这里必须是字符数字组成
	Integer iii = new Integer(s);
	System.out.println(s);
}
}

转换

int类型和String类型的相互转换

int-------String

int num =100;

方式一

	    String s1 = "" + number;
		System.out.println(s1);

方式二(valueOf可以把任何类型转成字符串)

        String s2 = String.valueOf(number);
		System.out.println(s2);

方式三
int—Integer----String

		Integer i = new Integer(number);
		String s3 = i.toString();
		System.out.println(s3);

方式四

		String s4 = Integer.toString(number);
		System.out.println(s4);

String-------int

String s =“100”;

方式一

		Integer ii = new Integer(s);
		int x =ii.intValue();
		System.out.println(x);

方式二

		int y = Integer.parseInt(s);
		System.out.println(y);

进制转换

进制间转换	方法	说明
十进制到二进制	toBinaryString(int i)	将一个十进制整数转换成字符串形式的二进制数
十进制到八进制	toOctalString(int i)	将一个十进制整数转换成字符串形式的八进制数
十进制到十六进制	toHexString(int i)	将一个十进制整数转换成字符串形式的十六进制数
十进制到其他进制	toString(int i,int radix)	将一个十进制数转换字符串形式的radix进制数，radix为进制值
其他进制到十进制	int parseInt(String s, int radix)	将一个radix进制的数转换为十进制

public static void main(String[] args)
	{
		//十进制到二进制，八进制，十六进制
		System.out.println(Integer.toBinaryString(100));
		System.out.println(Integer.toOctalString(100));
		System.out.println(Integer.toHexString(100));
		System.out.println("--------");
		
		//十进制到其他进制
		System.out.println(Integer.toString(100,10));
		System.out.println(Integer.toString(100,2));
		System.out.println(Integer.toString(100,8));
		System.out.println(Integer.toString(100,15));
		System.out.println(Integer.toString(100,5));
		System.out.println(Integer.toString(100,7));
		System.out.println(Integer.toString(100,-7));
		System.out.println(Integer.toString(100,70));
		System.out.println(Integer.toString(100,34));
		System.out.println(Integer.toString(100,37));
		System.out.println(Integer.toString(100,36));
		
		//其他进制转换为十进制
		System.out.println(Integer.parseInt("100",10));
		System.out.println(Integer.parseInt("100",2));
		System.out.println(Integer.parseInt("100",4));
		System.out.println(Integer.parseInt("100",16));
		System.out.println(Integer.parseInt("100",23));
		//System.out.println(Integer.parseInt("123",2));出错，因为2进制没有3
	}

装箱和拆箱

装箱：将基本数据类型变为包装类对象。
拆箱：将包装类型变为基本类型

面试

通过查看原码可知，java针对-128-127之间的数据做了一个数据缓冲池。
A：如果数据是该范围内的，每次并不创建新的空间。
B：如果数据是该范围内的，就new一个空间

public static void main(String[] args)
	{
		Integer i1 = new Integer(127);
		Integer i2 = new Integer(127);
		System.out.println(i1 == i2);//false
		System.out.println(i1.equals(i2));//true重写了equals方法，比较的内容
		
		
		Integer i3 = new Integer(128);
		Integer i4 = new Integer(128);
		System.out.println(i3 == i4);//false
		System.out.println(i3.equals(i4));//true
	
		Integer i5 = 128;
		Integer i6 = 128;
		System.out.println(i5 == i6);//false
		System.out.println(i5.equals(i6));//true
		
		Integer i7 = 127;
		Integer i8 = 127;
		System.out.println(i7 == i8);//true
		System.out.println(i7.equals(i8));//true

Character

概述：

Character类在对象中包装了一个char的值,用于对单个字符进行操作。
该类提供了几种方法来操纵字符，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写等。

构造方法

public Character(char value)：将char类型转换为Character类。

注意：char和Character类之间的转换方法与int和Integer类之间的转换方法相同

成员方法

序号	方法	说明
1	isDigit()	是否是一个数字字符
2	isWhiteSpace()	是否是一个空格
3	isUpperCase()	是否是大写字母
4	isLowerCase()	是否是小写字母
5	toUpperCase()	指定字母的大写形式
6	toLowerCase()	指定字母的小写形式
7	toString()	返回字符的字符串形式

public static void main(String[] args)
	{
		//public static boolean isUpperCase(int codePoint)判断给定的字符是否为大写字符
		System.out.println(Character.isUpperCase('A'));
		System.out.println(Character.isUpperCase('a'));
		System.out.println(Character.isUpperCase('0'));
		
		//public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
		System.out.println(Character.isUpperCase('A'));
		System.out.println(Character.isUpperCase('a'));
		System.out.println(Character.isUpperCase('0'));
		
		// public static boolean isDigit(int codePoint):判断给定的字符是否是数字
		System.out.println(Character.isUpperCase('A'));
		System.out.println(Character.isUpperCase('a'));
		System.out.println(Character.isUpperCase('0'));
		
		//public static char toUpperCase(char ch):把给定的字符转换为大写字符
		System.out.println(Character.toUpperCase('a'));
		
		//public static char toLowerCase(char ch):把给定的字符转换为小写字符
		System.out.println(Character.toLowerCase('A'));
	}