4数组 | Dylanの博客

•数组是多个相同类型数据的组合，实现对这些数据的统一管理

•数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量

•数组中的元素可以是任何数据类型，包括基本类型和引用类型

4.1 一维数组

<类型> var[]; 或 <类型> [] var;

eg: int[] a; double d[]; String[] args; Person p[];

Java语言中声明数组类型的变量时不允许指定数组的长度(数组中元素的个数)

如：int a[3] //非法

创建并使用数组：

4.2 多维数组

多维数组可以理解为由若干个低维数组所组成的数组。

•Java中多维数组的声明和初始化应按从高维到低维的顺序进行。

•Java中多维数组不必须是规则矩阵形式。

eg:  int  a[][]= {{1,2},{3,4,0,9},{5,6,7}};
     int[][] a = new int[3][4];	
     int[][] t = new int[3][];
     t[0] = new int[4];
     t[1] = new int[2];
     int[][] b = new int[][4];

4.2.1多维数组初始化

静态初始化

1 2	int a[][] = {{1,2},{2,3},{3,4,5}}; int b[3][2] = {{1,2},{2,3},{4,5}}; //非法

动态初始化

int a = new int[3][]; 
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
a[0][0] = 45;
a[0][1] = 87;
……
a[2][2] = 99;

实例1

public class test
{	public static void main(String args[])
	{ int[][] myArray=new int[3][];
	  myArray[0]=new int[3];
	  myArray[1]=new int[2];
	  myArray[2]=new int[3];       
     myArray[0][0]=1;myArray[0][1]=2;
     myArray[0][2]=3;
     myArray[1][0]=1;myArray[1][1]=2;	        
     myArray[2][0]=1;myArray[2][1]=2;
     myArray[2][2]=3;
     for(int i=0;i<3;i++)
     {for(int j=0;j<myArray[i].length;j++)	     	    
      {System.out.print(myArray[i][j]+"  ");  }
	   System.out.println();     //换行；
}}}

1 2 3 
1 2 
1 2 3

实例2

public class test
{	public static void main(String args[])
	{   char[] s={'A','B','C','D'};
	    for (int i=0; i<s.length; i++ ) 
	    {	System.out.print(s[i]+"  ");  }
       System.out.println();    
	    int [][] dd;
	    dd=new int[][]{{1,2},{1,2,3},{1,2,3}};	    
	    for(int i=0;i<dd.length;i++)
	    {for(int j=0;j<dd[i].length;j++)
	    	{System.out.print(dd[i][j]+"  "); }
	      System.out.println();
	    }
	}
}

A B C D
1 2 
1 2 3
1 2 3

4.2.2数组的枚举

public class foreachdemo
{public static void main(String args[])
  { String[] s;
    s = new String[]{"A","B","C","D"};
   //以上两行同String s[]={"A","B","C","D"};
    for(String c :  s )   {System.out.print(c+"  ");  }	   
    System.out.println();    
	    int [][] dd;
	    dd=new int[][]{{1,2},{1,2,3},{1,2,3}};	    
	    for(int[] p : dd)
	    { for(int obj : p){ System.out.print(obj+"  "); }
	      System.out.println();
	    }
	}
}

A B C D
1 2 
2 3
1 2 3

4.2.3数组拷贝

java.lang.System类的arraycopy()方法提供了数组元素复制功能——将一个数组的连续多个元素的值批量复制到另一个数组中。

int source[] = { 1, 2, 3, 4, 5, 6 };  //源数组
int dest[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
// 目的数组
System.arraycopy(source, 0, dest, 0, 3);
// 复制源数组中从下标0开始的3个元素
//到数组，从下标0的位置开始存储。

public class test
{	public static void main(String args[])
	{int source[] = { 1, 2, 3, 4, 5, 6 }; //源数组
    int newarray[]=source;        // 目标数组
    int dest[] = { 0, 0, 0, 0, 6, 5, 4, 3, 2, 1 }; 
	 System.arraycopy(source, 0, dest, 0,      
                                                      source.length); 
    for(int i=0;i<dest.length;i++)
     { System.out.print("  " + dest[i]); }
	}
}
1 2 3 4 5 6 4 3 2 1

4.2.4 Instanceof

instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。

这里说明下：

1.类的实例包含本身的实例，以及所有直接或间接子类的实例

2.instanceof左边显式声明的类型与右边操作元必须是同种类或存在继承关系，也就是说需要位于同一个继承树，否则会编译错误

public class instancedemo
{	  public static void main(String args[])
	  {  int[] a=new int[5];
	  	int[] b=new int[4];
	  	int[][] c=new int[2][3];
	     System.out.println(a instanceof Object);
	     System.out.println(a instanceof int[]);
	     System.out.println(c instanceof int[][]);
	     System.out.println(c[0] instanceof int[]);
	  }
}

4.2.5数组初始化总结

一维数组

 1)  int[] a;   //声明,没有初始化
 2)  int[] a=new int[5];   //初始化为默认值,int型为0
 3)  int[] a={1,2,3,4,5};  //初始化为给定值 

 4)  int[] a=new int[]{1,2,3,4,5};  //同(3)  
     int[] a=new int[5]{1,2,3,4,5}; //错误,如果提供了数组初始化操作，则不能定义维表达式 

  5) int[] a;   
     a=new int[5];    //正确,同(2)一样
    int[] a;     
     a={1,2,3,4,5};   //错误,数组常量只能在初始化操作中使用，如（3）
 6)  int a[];
     a[0]=1;   //错误,因为数组没有初始化,不能赋值
     a[1]=2;

二维数组

1)  int[][] a;  //声明,没有初始化

2)  int[][] a=new int[2][3];    //初始化为默认值,int型为0

3)  int[][] a={{1,2},{2,3},{3,4}};   //初始化为给定值 
      int[][] a={{1,2},{2,3},{3,4,5}};//没有错,数组空间不是连//续分配的，所以不要求每一维的大小相同

4)   int[][] a=new int[2][];
      a[0]=new int[3];  //a[0]其实就是一个数组
      a[1]=new int[4];  //每一维的大小可以不一样;
5) int[][] a=new int[][]{{1,2},{2,3},{3,4,5}};   //同(3)    int[] a=new int[5]{{1,2},{2,3},{3,4,5}};  //错误,如果提供了数组初始化操作，则不能定义维表达式 
   int[][] a=new int[2][];     
   a[0]={1,2,3,4,5};   //错误,数组常量只能在初始 //化操作中使用
6) int[][] a=new int[2][];    
    a[0][1]=1;   //错误,第二维没有初始化,不能赋值,java.lang.NullPointerException异常

4.2.6 Array类

该类提供了很多对数组进行操作的方法，如：

equals(): 比较两个数组是否相同，只有两个数组容量相同，且每个对应元素都一样时，才为true。

fill(): 向数组中填充数据。

sort(): 将数组元素按升序排列。

binarySearch(): 在数组中各元素已经按升序排列的条件下，从数组中查找指定的元素。

import java.util.*;
public class ArrayDemo
{ public static void main(String args[])
	{String[] s1={"zhangsan","lisi","wangwu","liliu","yaoqi"};
    String[] s2={"zhangsan","lisi","wangwu","liliu","yaoqi"};
	 System.out.println(Arrays.equals(s1,s2));
	 Arrays.sort(s1);
	 for(int i=0;i<s1.length;i++)
	  {System.out.println(s1[i]); }
	  }
}
True
Liliu
Lisi
Wangwu
Yaoqi
zhangsan

4.3 字符数组

4.3.1字符串的声明与创建

声明字符串的格式是：String stringName；

字符串的创建格式： stringName = new String（字符串常量）;

或者 stringName =字符串常量;

举例：str= new String ( “student” );

str= “student” // 内存位置在专用的字符串区内

用一个已创建的字符串创建另外一个字符串：

s=“abc123”;

String t=String(s);

用字符数组创建：

char a[]={“W”,”H”,”U”,”T”};

String b=new String(a);

4.3.2与字符串有关的方法

确定字符串的长度：

public int length()

取得字符：

public char charAt(int index)

取得子串：

public String substring(int beginIndex)

public String substring(int beginIndex,int endIndex)

字符串内容的比较

public int compareTo(String stringName2)

public int compareToIgnoreCase(String stringName2)

public static void main(String args[]){
		String s = new String("武汉理工大学计算机学院");
		System.out.println(s + " 的长度：" + s.length());
		System.out.println(s + " 第三个字：" + s.charAt(2) );
		System.out.println(s + " 的子串： " + s.substring(6));
		String s1 = new String("ABCDE");
		String s2 = new String("ABCED");
		System.out.println("\"ABCDE\"和\"ABCED\"比较结果："+s1.compareTo(s2));
	   }
武汉理工大学计算机学院 的长度：11
武汉理工大学计算机学院 第三个字：理
武汉理工大学计算机学院 的子串： 计算机学院
"ABCDE"和"ABCED"比较结果：-1

字符串连接:

public String concat(String stringName2)

字符串检索:

public int indexOf(int ch)
public int indexOf(int ch,int fromIndex)
public int indexOf(String stringName2)
public int indexOf(String stringName2,int fromIndex)

字符数组转换为字符串:

public static String copyValueOf(char []ch1)
public static String copyValueOf(char []ch1,int cBegin,int cCount)

	public static void main(String args[]){
	    String s = new String("武汉理工大学计算机学院");
	    String s1 = "09级软件工程";
	    String s2 = s.concat(s1);
	    System.out.println(s + " 追加 " + s1 + " 是: ");
	    System.out.println(s2);
	    
	    System.out.println(s2+"首次出现‘学’字符的位置"+s2.indexOf("学"));
	    
	    char[] Str1 = {'h', 'e', 'l', 'l', 'o', ' ', 'r', 'u', 'n', 'o', 'o', 'b'};
        String Str2 = "";
        Str2 = Str2.copyValueOf( Str1 );
        System.out.println("返回结果：" + Str2);
        Str2 = Str2.copyValueOf( Str1, 2, 6 );
        System.out.println("返回结果（偏移量2,长度6）：" + Str2);
	   }
武汉理工大学计算机学院 追加 09级软件工程 是: 
武汉理工大学计算机学院09级软件工程
武汉理工大学计算机学院09级软件工程首次出现‘学’字符的位置5
返回结果：hello runoob
返回结果（偏移量2,长度6）：llo ru

字符串转换为字符数组

public char[] toCharArray()

将其他数据类型转换为字符串

public static String valueOf(boolean b)
public static String valueOf(char c)
public static String valueOf(int i)
public static String valueOf(long L)
public static String valueOf(float f)
public static String valueOf(double d)

字符串大小写转换

public String toUpperCase()
public String toLowerCase()

字符串内容的替换：

public String replace(char oldChar,char newChar)

删除字符串的前导空白和尾部空白：

public String trim()

public static void main(String args[]){
	    String s = new String("武汉理工大学计算机学院");
	    String s1 = "";
	    String s2 = "ABCDEFG";
	    char a[] = s.toCharArray() ;
	    int i =1000;
	    System.out.println("字符串转换为字符数组并输出第一位:  "+a[0]);
	    System.out.println(s1.valueOf(i));
	    System.out.println(s2.toLowerCase());
	   }
字符串转换为字符数组并输出第一位:  武
1000
abcdefg

4.3.3字符串缓冲区

StringBuffer的构造

public StringBuffer()

构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。

public StringBuffer(int capacity)

构造一个不带字符，但具有指定初始容量的字符串缓冲区。

public StringBuffer(String str)
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。

有关方法：

字符串缓冲区数据转换为字符串：public String toString()

添加字符：public StringBuffer append(int iv)

插入字符：public StringBuffer insert(int insertP,char cv)

替换字符：public StringBuffer replace(int start, int end, String stringv)

删除字符：public StringBuffer delete(int start,int end)
public StringBuffer deleteCharAt(int index)
清空字符串：public void setLength(int newLength)
取子串：1.public String substring(int start)

返回一个新的 String，它包含此字符序列当前所包含的字符子序列。该子字符串始于指定索引处的字符，一直到此字符串末尾。
2.public String substring(int start, int end)

返回一个新的 String，它包含此序列当前所包含的字符子序列。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符。

字符串反转：public StringBuffer reverse()

String与StringBuffer的区别

String:
是对象不是原始类型.
为不可变对象,一旦被创建,就不能修改它的值.
对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.
String 是final类,即不能被继承.

StringBuffer:
是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象
它只能通过构造函数来建立,
StringBuffer sb = new StringBuffer();
不能通过赋值符号对他进行赋值.
sb = “welcome to here!”;//error
对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer中赋值的时候可以通过它的append方法sb.append(“hello”);

字符串连接操作中StringBuffer的效率要比String高。String的连接操作就比StringBuffer多出了一些附加操作,效率低一些.

由于String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的值.这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.

判断回文对联

import javax.swing.JOptionPane;

public class Hello {
	static boolean palindromeCouplet (String s)   {
		   StringBuffer s1 = new StringBuffer(s);
		   return((s.compareTo(new String(s1.reverse()))==0) ? true :false)  ;
		 }	
	public static void main(String[] args) {	
	 	while(true){
	    String str=JOptionPane.showInputDialog( null,  
		"请输入一行汉字！\n结束程序按取消。",
		"判断是否可作回文联",
		JOptionPane.QUESTION_MESSAGE);    
	    
		if (str == null) {
	    	System.out.println("再见！");
	    	break;
	    	} 
	System.out.println("是否可作回文联：" +palindromeCouplet(str));
	     }
      }
}