Arrays的使用
这里主要介绍Arrays在排序方面的使用 对与数组排序可以直接调用sort方法实现 下面是两种排序方法的比较： 第一种采用循环实现排序：public class ArrayDemo {
public static void main(String[] args) {
int[] arr = {21, 23, 22, 89, 56};
String s = arraytoString(arr);
System.out.println("排序前的数组是："+s);
//冒泡排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 ; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
System.out.println("排序后的数组是："+arraytoString(arr));
}
public static String arraytoString(int[] arr) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
sb.append(arr[i]);
} else {
sb.append(arr[i]).append(",");
}
}
sb.append("]");
String s = sb.toString();
return s;
}
}
第二种:
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
int[] arr = {13,21,54,45,74,98};
System.out.println("排序前的结果是："+Arrays.toString(arr));
Arrays.sort(arr);
System.out.println("排序后的结果是："+Arrays.toString(arr));
}
}
包装类
装箱和拆箱操作装箱就是：将int包装为Integer，反过来便是拆箱(拆箱操作是编译器自动完成的)
Integer—>int
int---->Integer
，另外下面也给出了Integer和String类型相互转化的方法
示例01：
String和Integer相互转化的方法：
public class Intgear {
public static void main(String[] args) {
//以前使用的创建Integer对象的方法
//Integer为引用类型，int为基本类型
Integer i = new Integer(23);
//现在以前使用的创建Integer对象的方法
Integer i1 = Integer.valueOf(20);
Integer i2 = Integer.valueOf("100");
System.out.println(i1);
System.out.println(i2);
/*Byte b1 = Byte.valueOf((byte) 2);
System.out.println(b1);
String s = String.valueOf("asd");
System.out.println(s);*/
System.out.println("--------");
//Integer-----》String
int number = 200;
//方法1
String s1 = "" + number;
System.out.println(s1);
//方法二
//public static String valueOf(float f)
//是static类型的所以使用String调用
//------------------------------------------------------提倡使用static类型的可以直接转化
String s2 = String.valueOf(number);
System.out.println(s2);
System.out.println("--------");
//String-----》Integer
//方法一
String s3 = "100";
Integer i3 = Integer.valueOf(s3);
//public int intValue()
//不是static类型的所以直接使用对象i3调用
int i4 = i3.intValue();
System.out.println(i4);
//方法二
//------------------------------------------------------提倡使用static类型的可以直接转化
//public static int parseInt(String s)
int i5 = Integer.parseInt(s3);
System.out.println(i5);
}
}
示例02：
Integer 和int
public class Integer {
/*
* 装箱和拆箱*/
public static void main(String[] args) {
//Integer属于引用类型，int属于操作类型
//装箱操作
java.lang.Integer i = java.lang.Integer.valueOf(23);
int i1 = i + 23;
System.out.println(i);
System.out.println(i1);
//拆箱操作
int i2 = i;//系统自己默认做了
System.out.println(i);
}
}
内部类
内部类顾名思义就是：在一个类里面又装了一个在，在使用的时候需要创建内部类的对象：public class Outer {
/*
内部类可以访问外部类的所有内容，包括私有
* 外部类访问内部类必须通过创建对象*/
private int num = 10;
public class Inter {
public void show() {
//内部类可以访问外部类的所有内容，包括私有
System.out.println(num);
}
}
//外部类访问内部类必须通过创建对象,而且创建对象也必须要--在方法---里面
public void method() {
Inter i1 = new Inter();
i1.show();
}
}
内部类在外部测试类使用的案例01
Out类：
public class Outer {
private int num = 10;
//成员内部类
public class Inner{
public void show(){
System.out.println(num);
}
}
//外部类调用内部类的方法
//创建对象
public void method(){
Inner i = new Inner();
i.show();
}
}
测试类：
public class OuterDemo {
public static void main(String[] args) {
//了解即可，内部类的创建对象方法
/*Outer.Inner oi = new Outer().Inner();
oi.show();*/
//实际上内部类对外不是不可见的，所以在外部只能通过她所创建的外部类来创建对象，使用外部类访问，然后再测试类里面在进行调用方法
Outer o = new Outer();
o.method();//o.method--->>show
}
}
匿名内部类
==匿名内部类需要一个接口，----实现了该接口的匿名对象------== 简单理解： 在一个类内部的方法中通过new一个接口并且重写所在的方法来实现； 接口：public interface Inter {
void show();
}
外部类：
public class Outer {
public void method(){
/*
* 匿名内部类的格式：
* new 接口名称(){
};
* */
//匿名内部类需要一个接口，----实现了该接口的匿名对象------
new Inter(){
@Override
public void show() {
System.out.println("匿名内部类");
}
}.show();
Inter i = new Inter(){
@Override
public void show() {
System.out.println("匿名内部类");
}
};
i.show();
}
}
测试类：
public class OuterDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
