类Arrays和Integer

最新推荐文章于 2021-10-21 11:34:23 发布

骨语

最新推荐文章于 2021-10-21 11:34:23 发布

阅读量561

点赞数

本文链接：https://blog.csdn.net/weixin_43917444/article/details/92166058

版权

类Arrays

public class Arrays extends Object
所在的包：java.util
作用：此类包含用来操作数组（比如排序和搜索）的各种方法。

方法

1、binarySearch（二分查找）

public static int binarySearch (byte[] a, byte key)
使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。

public static int binarySearch (byte[] a, int fromIndex, int toIndex, byte key)
使用二分搜索法来搜索指定的 byte 型数组的范围，以获得指定的值。

这个方法可同样对int 型数组、char型数组、 long型数组、 short型数组、 double型数组、 float 型数组、Object 型数组进行指定搜索。

//注意：用二分查找的前提是数组必须是有序的

原型实现：

package com.array;
public class Array {
	//需求：折半查找
	 public static void main(String[] args) {
		  int [] arr= {12,23,34,41,57,63,77,89,90};
		  System.out.println(find(arr,23));
		  System.out.println(find(arr,89));
		  System.out.println(find(arr,10));
	 }
	 public static int find(int [] arr,int value) {
		  int min=0;
		  int max=arr.length-1;
		  int mid=(max+min)/2;
		  while(arr[mid]!=value) {
			   if(arr[mid]>value) {
			   	 max=mid-1;
			   } else if(arr[mid]<value) {
			    	min=mid+1;
			   }
			   mid=(min+max)/2;
			   if(min>max) {
				 return -1;
			   }
		 }
		return mid+1;
	 }
}

例子：

package com.array;
import java.util.Arrays;
public class Array {
	  int [] arr= {11,22,33,44,55,66};
	  System.out.println(Arrays.binarySearch(arr, 11));//0
	  System.out.println(Arrays.binarySearch(arr, 66));//5
	  System.out.println(Arrays.binarySearch(arr, 12));//-2:（（-1）* 插入点-1）
	  //当所找的key不在原数组中，返回值为此数在原数组中的可插入点乘以（-1）再减去1的值
}

2、sort（排序）

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

public static void sort (byte[] a, int fromIndex, int toIndex)
对指定 byte 型数组的指定范围按数字升序进行排序。

这个方法可同样对int 型数组、char型数组、 long型数组、 short型数组、 double型数组、 float 型数组、Object 型数组进行升序排序。

原型实现：

package com.array;
public class Demo1_Array {
	public static void main(String[] args) {
		  int [] arr= {56,12,31,78,25,9,44};
		  buublesort(arr);
		  //selectsort(arr);
		  print(arr);
	 }
	 //需求：冒泡排序
	 public static void buublesort(int [] arr) {
		  for(int i=0;i<arr.length-1;i++) {
			   for(int j=0;j<arr.length-1-i;j++) {
				    if(arr[j]>arr[j+1]) {
					     /*int temp;
					     temp=arr[j];
					     arr[j]=arr[j+1];
					     arr[j+1]=temp;*/
					     swap(arr,j,j+1);
				     }
			    }
		  }
	 }
	 //需求：选择排序
	 public static void selectsort(int [] arr) {
		  for(int i=0;i<arr.length-1;i++) {
			   for(int j=i+1;j<arr.length;j++) {
				    if(arr[i]>arr[j]) {
					     /*int temp;
					     temp=arr[i];
					     arr[i]=arr[j];
					     arr[j]=temp;*/
					     swap(arr,i,j);
				   }
			    }
		  }
	}
	//抽取出相同的代码
	 private static void swap(int [] arr,int i,int j) {
		  int temp;
		  temp=arr[i];
		  arr[i]=arr[j];
		  arr[j]=temp;
	 }
	 public static void print(int [] arr) {
		  for(int i=0;i<arr.length;i++) {
		   	System.out.print(arr[i]+" ");
		  }
	 }
}

例子：

package com.array;
import java.util.Arrays;
public static void main(String[] args) {
	int [] arr= {33,11,22,44,55,66};
	  System.out.println(Arrays.toString(arr));
	  
	  Arrays.sort(arr);
	  System.out.println(Arrays.toString(arr));
}

3、toString（数组转字符串形式）

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

这个方法可同样对byte型数组、int 型数组、char型数组、 long型数组、 short型数组、 double型数组、 float 型数组、Object 型数组进行升序排序。

例子如上

类Integer

public final class Integer extends Number implements Comparable < Integer >
所在的包：java.lang
作用：Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型段。此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

构造方法

public Integer(int value)
构造一个新分配的 Integer 对象，它表示指定的 int 值。
public Integer(String s)
构造一个新分配的 Integer 对象，它表示 String 参数所指示的int 值。

方法

（1）基本方法&&基本常量

public static String toBinaryString (int i)
以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。

public static String toHexString (int i)
以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。

public static String toOctalString(int i)
以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

public static int MAX_VALUE
值为 231－1 的常量，它表示 int 类型能够表示的最大值。

public static int MIN_VALUE
值为－231 的常量，它表示 int 类型能够表示的最小值。

（2）构造方法

public Integer(int value)
构造一个新分配的 Integer 对象，它表示指定的 int值。

public Integer(String s) //String s是数字字符串
构造一个新分配的 Integer 对象，它表示 String 参数所指示的int 值。

例子：
Integer i=new Integer(100);
System.out.println(i);

/* Integer i2=new Integer(“abc”);//java.lang.NumberFormatException数字格式错误
System.out.println(i2);*/

Integer i3=new Integer(“100”);//将数字字符串转换为对应的数字
System.out.println(i3);==

（3）在int和String之间转换的方法

String–>int

1、public static int parseInt(String s) //由static修饰的方法可以用 类名 . 直接调用
将字符串参数作为有符号的十进制整数进行解析。

例子：
int i = Integer . parseInt(“100”);

2、public Integer(String s) //String s是数字字符串
构造一个新分配的 Integer 对象，它表示 String 参数所指示的int 值。
public int intValue()
int 类型返回该 Integer 的值。

例子:
Integer i=new Integer(“100”);
int i1 = i . intValue();

int–>String

例子（最简单的方法）：
String s = 100+“”；

1、public String toString()
返回一个表示该 Integer 值的 String 对象。

例子：
Integer i = new Integer (100);
String s = i . toString();

public static String toString(int i)
返回一个表示指定整数的 String 对象。

例子：
String s = Integer . toString(100);

public static String toString(int i, int radix)
返回用第二个参数指定基数表示的第一个参数的字符串表示形式。

2、public static Integer valueOf(int i)
返回一个表示指定的 int 值的 Integer 实例。

例子：
Integer i = Integer . valueOf(100);
String s = i.toString();
//String s = Integer . valueOf(100) . toString();

public static Integer valueOf(String s)
返回保存指定的 String 的值的 Integer 对象。

public static Integer valueOf(String s, int radix)
返回一个 Integer对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。

自动拆箱和自动装箱

1、原型实现（常用方法）

int x = 100;
Integer i1 = new Integer (x);//将基本数据类型包装成类，装箱
int y = i1 . intValueOf();//将类的对象转换成基本数据类型，拆箱

2、实际自动拆装箱

Integer x = 100;
int y = x+100;

比较equals

1、public boolean equals (Object obj)
比较此对象与指定对象。当且仅当参数不为 null，并且是一个与该对象包含相同 int 值的Integer 对象时，结果为 true。

2、==
基本数据类型：判断值是否相等
引用数据类型：判断地址值是否相等

例子：
Integer i1=new Integer(127);
Integer i2=new Integer(127);
System.out.println(i1==i2);//false 创建对象所获得地址值不相同
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("----------------");

Integer i5=128;
Integer i6=128;
System.out.println(i5==i6);//false
System.out.println(i5.equals(i6));//true
System.out.println("------------------ ");

Integer i7=127;
Integer i8=127;
System.out.println(i7==i8);//true
System.out.println(i7.equals(i8));//true
System.out.println("----------------");
/*
*-128~127是byte的取值范围，如果在这个取值范围内，自动装箱就不会新创建对象，就会从常量池中获取，因而比较的就是值
*如果超过了byte取值范围会新创建对象，从而比较的时对象的地址值
*/