Day08

原创已于 2022-03-23 11:30:11 修改

· 334 阅读

0 ·

版权

文章标签：

#java

于 2022-01-22 00:04:15 首次发布

JavaSE 专栏收录该内容

13 篇文章

订阅专栏

本文介绍了Java编程中的数组冒泡排序、API的概念、基本数据类型包装类及其用途，详细讲解了Integer类的使用，包括自动装箱和拆箱，并探讨了Object类的equals()和toString()方法以及Arrays类的实用方法如equals()和sort()。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数组的冒泡排序

每排一趟确定一个位置

public static void main(String [] args)

{

int [] a = {5,4,3,2,1};

for(int i = 0; i < a.length-1;i++)

{

for(int j=0;j < a.length-i-1;j++)

{

if(a[j]>a[j+1])

{

int t = a[j];

a[j] = a[j+1];

a[j+1] = t；

}

System.out.println(Arrays.toString(a));

}

API

API指的是java中所提供的类，接口；

API指的是官方给出的类，接口的说明文档。

基本数据类型包装类

8种基本数据类型 byte short int long double char boolean 是关键字声明的，不是面向对象的。

Java是面向对象的语言，所以Java为每一种基本类型创造了一个包装类。这些包装类中包含了一个基本类型，还有一些操作的方法。

基本数据类型包装类

byte Byte

short Short

char Char

int Integer

long Long

float Float

double Double

boolean Boolean

例子：int--->Integer(包装类)

Integer a = new Integer(10);

System.out.println(a.intValue());//引用面向对象的思想

System.out.println(Integer.MAX_VALUE);//int的最大值2147483647

// public static final int MAX_VALUE = 0x7fffffff;16进制

System.out.println(Integer.BYTES）;//4个字节

System.out.println(Integer.SIZE);//32位

System.out.println(Integer.MIN_VALUE);//int的最小值 -2147483648

// public static final int MIN_VALUE = 0x80000000;8进制

包装类的用途：

1）作为和基本数据类型对应的类型存在

2）包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。操作方法以数据类型转换为主，其他方法理解较为简单。

Integer b = new Integer(“10”);//将String类型转换为int类型

String s = “10a”；

Integer b = new Integer(s);//出错，s必须是数不能带字母

compare：

System.out.println(Integer.compare(10,12));//前小后大-1 相等0 前大后小1

System.out.println(b.compareTo(12)）;//-1

System.out.println(Integer.max(10,12));//12

System.out.println(Integer.toBinaryString(2)）;//10 2进制

System.out.println(Integer.toOctalString(8)）;//10 8进制

System.out.println(Integer.toHexString(16)）;//10 16进制

int a = 10;//基本类型

Integer b = new Integer(a);//把基本类型包装成引用类型

int c = b.intValue();//取出包装类型中的基本类型包装类型转为基本类型

Integer d = Integer.valueof(c);//把一个基本类型转为包装类型

int e = Integer.parseInt("10");//把String转为基本类型

System.out.println(d.toString()）;

自动装箱和拆箱

自动装箱

自动将基本类型转为引用类型

int x =10;

Integer y = x;

自动拆箱

自动将引用类型转为基本类型

Integer a = new Integer(10);

int b = a；//默认调用intValue()

Integer.valueof(x);

//自动装箱时默认调用valueof() 里面缓存了 -128~+127对象在这个区间之内不重写创建对象，直接获取，超过就创建对象，m，n两个就不相等

Integer m =127;

Integer n = 127;

System.out.println(m == n);//true

Integer m =new Integer(127);

Integer n = new Integer(127);

System.out.println(m == n);//false 地址不同

== 如果是基本类型，比较值是否相等

==如果比较是引用类型比较对象地址是否相等

object类

toString():

public String toString()

{

return(getClass().getname() + "@" + Integer.toHexString(hascode());

}

//如果我们的类重写了object中的toString（），那么就会调用我们自己的。

equals():

Car c1 = new Car(100,"宝马"); Car c2 = new Car(100,"宝马");

/* Object类中的equals默认比较的对象地址 ==

public boolean equals(Object obj) { return (this == obj); }

System.out.println(c1.equals(c2));//false 重写之后就会true

System.out.println(c1==c2);//false

/* equals() 一般的类都会重写,比较的是对象中包含的内容是否相等 */

String s1 = new String("abc"); String s2 = new String("abc"); System.out.println(s1.equals(s2));//true

Arrays类

java.util.Arrays

int [] a = {1,2,3,4,5};

int [] b = {1,2,3,4,6};

System.out.println(a==b);//false

System.out.println(Arrays.equals(a,b));//equals() 大家公认的是比较内容

sort()

int [] a = {3,4,2,1,5};

Arrays.sort(a);

Arrays.sort(a,0,5);//0是下界，5是上界

//二分查找数组必须是有序的

System.out.println(Arrays.binarySearch(a,1));

System.out.println(Arrays.toString(a));