Java——匿名内部类、Object类、Scanner类、String类、StringBuffer类、基本数据类型包装类和数组排序

文章目录

• • 匿名内部类
  • Object类
  • Objects类
  • Scanner类
  • String类
  • StringBuffer类
  • 包装类
  • • 基本类型转换为String
    • 包装类Integer类
  • 数组排序

匿名内部类

匿名内部类时局部内部类的简写，使用代码如下：

 public abstract class Animal {
    public abstract void eat();
}
public interface MyInterFace {
    public abstract void method();
}
public class Dog  {
    public Animal dshow(){
        return (new Animal() {
            @Override
            public void eat() {
                System.out.println("匿名内部类作为返回值");
            }
        });
    }

    public MyInterFace dshow1() {
        return (new MyInterFace() {
            @Override
            public void method() {
                System.out.println("匿名内部类作为返回值");
            }
        });
    }
}
public class Test {
    public static void main(String[] args) {
        //匿名内部类作为show（）的形参第一种形式
        show(new Animal() {
            @Override
            public void eat() {
                System.out.println("匿名内部类直接作为方法的形参");
            }
        });
        System.out.println("-----------------------------------");
        //匿名内部类作为show（）的形参第二种形式
        Animal an1=new Animal() {
            @Override
            public void eat() {
                System.out.println("匿名内部类间接作为方法的形参");
            }
        };
        show(an1);
        System.out.println("-----------------------------------");
        //匿名内部类作为返回值
        Dog dog=new Dog();
        Animal an2=dog.dshow();
        show(an2);
        System.out.println("-----------------------------------");
        Dog dog1=new Dog();
        MyInterFace my =dog1.dshow1();
        show1(my);
    }
    public static void show(Animal an){
        an.eat();
    }
    public static void show1(MyInterFace my){
        my.method();
    }
}

需要注意的是：向下转型

Object类

Objects类

在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

• public static boolean equals(Object a, Object b):判断两个对象是否相等。

我们可以查看一下源码，学习一下：

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

Scanner类

String类

注意：（1）对String类的特点：字符串被创建，其值不在改变，改变的是其引用的值，利用内存图对其进行详解：

（2）对String s=new String(“hello”)和String s1="hello"的区别，利用内存图展示：

（3）理解好含左不含右的意义。

StringBuffer类

（1）String和StringBuffer的相互转换，代码如下：

public class StringBufferTest2 {
    public static void main(String[] args) {
        //String-----StriingBuffer
        String str="sgjjlk";
        StringBuffer stringBuffer1 = new StringBuffer(str);
        StringBuffer stringBuffer2 = new StringBuffer().append(str);
        System.out.println(stringBuffer1);
        System.out.println(stringBuffer2);
        System.out.println("-------------------------------");
        //StringBuffer-------String
        StringBuffer s1 = new StringBuffer("cvhjbjk");
        String s2 = s1.toString();//toString()是转换为字符串输出
        System.out.println(s2);
        String s3 = s1.substring(0);//substring()截取字符串，返回的是字符串类型
        System.out.println(s3);

    }
}

（2）String和StringBuffer的作为形参的区别，代码如下：

public class StringBUffertest3 {
    public static void main(String[] args) {
        /*String 作为形参，虽然是引用类型，但是是一个常量，
        可以作为基本数据类型进行数据传递，但是其形参的改变不会改变实参的值
        * */
        String str="asdfg";
        setString(str);
        System.out.println(str);
        /**
         * StringBuffer作为形参，其是引用类型，形参的改变会影响实参的改变
         */
        StringBuffer s= new StringBuffer("asdfghjkl");
        setStringBuffer(s);
        System.out.println(s);
    }
    public static void setString(String str){
        str = str.replace('d', 'e');
        System.out.println(str);
    }
    public static void setStringBuffer(StringBuffer str){
        str=str.append("asdf").replace(2,5,"ty");
        System.out.println(str);
    }
}

包装类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

• 装箱：从基本类型转换为对应的包装类对象。
• 拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：（看懂代码即可）

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

int num = i.intValue();

自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

基本类型与字符串之间的转换

基本类型转换为String

基本类型转换String总共有三种方式，查看课后资料可以得知，这里只讲最简单的一种方式：

基本类型直接与””相连接即可；如：34+""

String转换成对应的基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

• public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
• public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
• public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
• public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
• public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
• public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
• public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

代码使用（仅以Integer类的静态方法parseXxx为例）如：

public class Demo18WrapperParse {
    public static void main(String[] args) {
        int num = Integer.parseInt("100");
    }
}

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

包装类Integer类

（1）int与String的相互转换代码：

public class Test {
    public static void main(String[] args) {
        //int ------------String
        int num=1000;
        //字符串的拼接
        String str="";
        str+=num;
        System.out.println(str);
        System.out.println("-----------------------");
        //valueOf(),将任意的数据类型转换为字符串
        String s = String.valueOf(num);
        System.out.println(s);
        System.out.println("-----------------------");
        //int---Integer---String
        Integer i1 = new Integer(num);
        String s1 = i1.toString(num);//toString()必须对象调用方法
        System.out.println(s1);
        System.out.println("-----------------------");

        //String-----int
        String st="111111";
        Integer in1 = new Integer(st);
        int in2 = in1.intValue(); //不是静态方法，返回的是int型数字
        System.out.println(in2);
        System.out.println("----------------------");
        int in3 = Integer.parseInt(st);   //静态的方法，只能通过类名来调用
        System.out.println(in3);

    }
}

特别注意，静态方法的调用时类名调用而不是对象的调用。

数组排序

（1）冒泡排序代码：

import java.util.Arrays;

public class MaoPaoSort {
    public static void main(String[] args) {
        int[] arr={24,69,80,57,13};
        sort(arr);
    }
    public static void sort(int[] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

（2）选择排序代码:

public class XUanZeTest {
    public static void main(String[] args) {
        int[] arr={24,69,80,57,13};
        sort(arr);
    }
    public static void sort(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 = arr[i];
                    arr[i] = arr[j ];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

（3）二分法排序代码：

public class ErFenFa {
    public static void main(String[] args) {
        int[] arr={12,54,2,4,89};
        sort(arr);
        int index=erfenfa(arr,4);
        System.out.println(index);
    }
    public static void sort(int[] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    public static int erfenfa(int[] arr,int value){
        int minIdex=0;
        int maxIndex=arr.length-1;
        int midIndex=(minIdex+maxIndex)/2;
        while(minIdex<=maxIndex) {
            if (value == arr[midIndex]) {
                System.out.println("找到对应的值，索引值为：" );
                return midIndex;
            } else if (value < arr[midIndex]) {
                maxIndex = midIndex - 1;
            } else {
                minIdex = midIndex + 1;
            }
            midIndex=(minIdex+maxIndex)/2;
        }
        return -1;
    }
}