数组、String

最新推荐文章于 2024-08-20 07:00:00 发布

Mr.madong

最新推荐文章于 2024-08-20 07:00:00 发布

阅读量1k

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/M983373615/article/details/73927946

版权

java 专栏收录该内容

65 篇文章 1 订阅

订阅专栏

简单java类：

一个类之中只包含基本的属性，setter、getter方法，这种类称为简单java类，对于简单java类的开发规则有如下几点：

类名称必须可以明确的表示出一类的定义，例如：Person、Emp、Dept
类之中的所有属性必须使用private进行封装
类之中的所有属性都必须定义相应的setter、getter；
类之中可以提供构造方法，为属性初始化，但是不管提供多少个构造方法,一定要保留有一个无参构造方法；
类之中不允许直接使用system.out.println()输出，所有内容要返回给被调用处输出。

例题：定义一个表示雇员的操作类，这个类之中包含雇员的编号、姓名、职位、基本工资、佣金，并且可以计算出一个雇员的月薪和年薪，可以返回一个雇员的完整信息。

class Emp
{
    private int empno ;
    private String ename ;
    private String ejob ;
    private double esal ;
    private double ecom ;
    public Emp(){}
    public Emp(int eno , String ena ,String ej , double es , double ec){
        empno = eno ;
        ename = ena ;
        ejob = ej ;
        esal = sa ;
        ecom = ec ;
    }
    public void setEmpno(int eno){
        empno = eno ;
    }
    public void setEname(String ena){
        ename = ena ;
    }
    public void setEjob(String ej){
        ejob = ej ;
    }
    public void setEsal(double es){
        esal = es ;
    }
    public void setEcom(double ec){
        ecom = ec ;
    }
    public int getEmpno(){
        return empno ;
    }
    public int getEname(){
        return ename ;
    }
    public int getEjob(){
        return job ;
    }
    public int getEsal(){
        return sal ;
    }
    public int getEcom(){
        return com ;
    }
public double salary(){
    return sal + com ;
}
public double income(){
    return salary()* 12 ;
}
public String getInfo(){
    return "雇员信息："+"\n"+
                " \t | - 编号：" + getEmpno() + "\n" +
                " \t | - 姓名：" + getEname() + "\n" +
                " \t | - 职位：" + getEjob() + "\n" +
                " \t | - 基本工资：" + getEsal() + "\n" +
                " \t | - 佣金：" + getEcom() + "\n" +
                " \t | - 月薪：" + salary() + "\n" +
                " \t | - 年薪：" + income() + "\n" +
}

}
public static void main(String args[]){
    Emp emp = new Emp(1234 , "史密斯" , "办事员" , 800.0 , 200.0) ;
    System.out.println(emp.getInfo()) ;
}

数组：

数组的定义格式：
动态初始化：数据类型数组名称 [] = new 数据类型 [长度]；数组内容都是默认值
静态初始化：数据类型数组名称 [] = new 数据类型 []{值，值…} ；

二维数组：
动态初始化：数据类型数组名称 [] []= new 数据类型 [长度][长度]；
静态初始化：数据类型数组名称 [] []= new 数据类型 [][]{{值，值…}，{值，值…}}；

如果要取得数组长度：数组名称.length

数组的两个基本操作方法：
**排序：**java.util.Arrays.sort(数组名称)；

说明：
(1)Arrays类中的sort()使用的是“经过调优的快速排序法”;
(2)比如int[]，double[]，char[]等基数据类型的数组，Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法。　
(3)要对基础类型的数组进行降序排序，需要将这些数组转化为对应的封装类数组，如Integer[]，Double[]，Character[]等，对这些类数组进行排序。(其实还不如先进行升序排序，自己在转为将序)。

用默认的升序对数组排序
函数原型：
static void sort(int[] a) 对指定的 int 型数组按数字升序进行排序。
static void sort(int[] a, int fromIndex, int toIndex) 对指定 int 型数组的指定范围按数字升序进行排序。
代码如下：　

import java.util.Arrays;
public class ArraysSort_11 {
    public static void main(String args[])
    {
        int[] a={1,4,-1,5,0};
        Arrays.sort(a);
        //数组a[]的内容变为{-1,0,1,4,5}
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+"  ");
    }
}

**数组拷贝：

System.Arraycopy(源数组名称，源数组开始点，目标数组名称，目标数组开始点，长度)；
示例：
System.arraycopy的用法：
int[] src = {1,3,5,7,9,11,13,15,17};

int[] dest = {2,4,6,8,10,12,14,16,18,20};

//从src中的第一个元素起复制三个元素，即1，3，5复盖到dest第2个元素开始的三个元素

System.arraycopy( src, 0, dest, 1, 3);
System.Arraycopy(源数组名称，源数组开始点，目标数组名称，目标数组开始点，长度)；

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

结果为：[2, 1, 3, 5, 10, 12, 14, 16, 18, 20]

还有其它的两种基本复制用法：

Arrays.copyOf的用法：
int[] src = {1,3,5,7,9,11,13,15,17};

int[] dest = {2,4,6,8,10,12,14,16,18,20};

//copyOf(是复制src数组从0开始的两个元素到新的数组对象)

int[] copyof=Arrays.copyOf(src, 2);

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

结果为：[1, 3]
Arrays.copyOfRange的用法

int[] src = {1,3,5,7,9,11,13,15,17};

int[] dest = {2,4,6,8,10,12,14,16,18,20};

//copyRange(从src数组中从0开始的第二个元素到第五个元素复制到新数组，含头不含尾)

int[] copyofRange=Arrays.copyOfRange(src, 2,6);

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

结果为：[5, 7, 9, 11]

注意：对象数组开辟之后需要为每一个数组元素分别进行是实例化操作。

String类两种对象实例化方式

直接赋值方式：String str = ”Hello” ;

public class Test2
{
    public static void main(String args[]){
        String str1 = "Hello" ;
        String str2 = new String("Hello") ;
        String str3 = str2 ;
        System.out.println(str1 == str2) ;    //false
        System.out.println(str1 == str3) ;    //false
        System.out.println(str2 == str3) ;    //true
    }
}

分析如下：

现在使用“==”是判断数值的相等，这里判断的是堆内存的地址数值是否相等。

*.equals()（用来比较内存中内容是否相等）

public class Test2
{
    public static void main(String args[]){
        String str1 = "Hello" ;
        String str2 = new String("Hello") ;
        String str3 = str2 ;
        System.out.println(str1.equals(str2)) ;    //true
        System.out.println(str1.equals(str3)) ;    //true
        System.out.println(str2.equals(str3)) ;    //true
    }
}

现在比较的不是内存的地址，而是比较内存中的内容是否相等。

比较“==”、equals()的区别?

“==”:比较的是字符串的数值是否想扥，属于数值比较。
Equals（）：比较的是两个字符串在内存中的内容是否相等，属于内存比较。
-

字符串常量是string的匿名对象

如果程序在定义字符串（使用“”），那么就表示一个string对象。

匿名对象可以调用类之中的方法和属性，如：”Hello”.equals();,那么这个字符串常量一定是一个对象。

String类的两种实例化操作的区别

分析直接赋值方式：String str = “Hello” ;

public class Test2
{
    public static void main(String args[]){
        String str1 = "Hello" ;
        String str2 = "Hello" ;
        String str3 = "Hello" ;

        System.out.println(str1 == str2) ;    //true
        System.out.println(str1 == str3) ;    //true
        System.out.println(str2 == str3) ;    //true
    }   
}

在string类进行设计时采用了一种共享设计模式的概念，在每一个运行的JVM底层存在一个字符串的对象池（Object Pool），如果用户采用直接赋值的方式，会将字符串的内容放到池中，以供其他继续使用直接赋值方式的string对象使用，如果新声明的字符串内容不再池中，则会开辟一个新的，继续放到池中，以供下次使用。

构造方法赋值：

public class Test2
{
    public static void main(String args[]){
        String str = new String("Hello");
        System.out.println(str) ;  

    }
}

使用构造方法的方式开辟的字符串对象，实际上开辟两块空间，其中一块称为垃圾。

入池方式：

直接入池：String str2 = “Hello” ;

public class Test2
{
    public static void main(String args[]){
        String str1 = new String("Hello");
        String str2 = "Hello" ;   //入池
        String str3 = "Hello" ;     //使用池对象
        System.out.println(str1 == str2) ;  //false
        System.out.println(str1 == str3) ;  //false
        System.out.println(str2 == str3) ;  //true

    }
}

使用构造方法实例化string对象，不会入池。

手工入池：String str1 = new String(“Hello”).intern();

public class Test2
{
    public static void main(String args[]){
        String str1 = new String("Hello").intern();     //手工入池
        String str2 = "Hello" ;   //入池
        String str3 = "Hello" ;     //使用池对象
        System.out.println(str1 == str2) ;  //false
        System.out.println(str1 == str3) ;  //false
        System.out.println(str2 == str3) ;  //true

    }
}

思考：String类的两种实例化方式的区别？

直接赋值：之开辟一块堆内存空间，字符串的内容可以入池，以供下次使用。
构造方法：开辟两块堆内存空间，又有成为垃圾，并且不能自动入池，使用intern()手工入池。

字符串的内容一旦声明就不可改变

public class Test2
{
    public static void main(String args[]){
        String str = "Hello" ;  
        str += " World" ;
        str = str + "!!!" ;
        System.out.println(str) ; 

    }
}