数组String

Posted 2022-01-13 Mr_madong

简单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) ; 

    

字符串的更改，实际上改变的是字符串对象的引用