_数组_多维数组_练习_矩阵运算----_数组的拷贝_排序_二分法_命令行参数_增强for循环

 

package cn.bjsxt.array2;

/**

 * _数组_多维数组_练习_矩阵运算

 * Matrix矩阵的联系

 * @author 神奇的梦

 */

public class Matrix {

/**

 * 打印制定的矩阵

 * @param c

 */

public static void print(int[][] c) {

for(int i=0;i<c.length;i++) {

　　for(int j=0;j<c[i].length;j++) {

　　　　// c[i][j]=a[i][j]+b[i][j];

　　　　System.out.print(c[i][j]+"\t");

　　}

}

System.out.println();

}

/**

 * @return

 * 返回int[][]二维数组 ，定义两个形参进行矩阵计算

 */

public static int[][] add(int[][] a,int[][] b){

　　// int[][] c需要和我们矩阵的长度是一样的，不然不行

　　int[][] c = new int [a.length] [a.length];

　　for(int i=0;i<a.length;i++) {

　　　　for(int j=0;j<a[i].length;j++) {

　　　　　　c[i][j] = a[i][j] + b[i][j];

　　　　　　System.out.print(c[i][j]);

　　　　}

　　}

System.out.println();

return c;

}

// 二阶矩阵

public static void main(String[] args) {

int [] [] a = {

　　　　　　{1,3},

　　　　　　{2,4}

　　　　　　};

int[][] b = {

　　　　　　{3,4},

　　　　　　{5,6}

};

int[][] c = new int [2][2];

int[][] d = add(a,b);

// c.print(a,b);

print(a);

add(a, b);

print(d);

// System.out.println( c[0][0]+"\t"+ c[0][1]);

// System.out.println( c[1][0]+"\t"+ c[1][1]);

 

c[0][0]=a[0][0]+b[0][0];

c[0][1]=a[0][1]+b[0][1];

c[1][0]=a[1][0]+b[1][0];

c[1][1]=a[1][1]+b[1][1];

}

}

_数组的拷贝_排序_二分法_命令行参数_增强for循环

数组的拷贝

System类里也包含了一个static void arraycopy(object src,int srcpos, object dest,int destpos, int length )方法，该方法可以将src数组里的元素赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。

String[] s = { “Mircosoft”,”IBM”,”Sum”,”Oracle”,”Apple” };

String[] sBak = new String[6];

System.arraycopy(s,0,sBak,0,s.length);

 

Java,util.Arrays;

类Arrays

此类包含用来操作数组(比如排序和搜索)的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

除非特别注明，否则如果指定数组引用为null，则此类中的方法都会抛出NullPointerException

1. 打印数组。

Int[] a = { 1,2 };

System.out.println( a );  

System.out.println( Array.toString(a) );

数组排序

Int[] a = { 1,2,323,23,543,12,59 };

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

Arrays.sort( a );

System.out.println( Array.toString(a) );

结果：

{ 1,2,323,23,543,12,59 }

{ 1,2,12,23,59,323,543 }

如果数组元素是引用类型，那么需要怎么做呢？（今天先不讲，后面讲容器时再讲！）

public class Test{

public static void main(String[] args){

Man[] msMans={ new Man(3,”a”),new Man(60,”b”),new Man(2,”c”) };

Arrays.sort( msMans );

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

}

}

class Man implements Comparable{

int age;

int id;

String name;

public Man( int age,String name ){

super();

this.age=age;

this.name=name;

}

}

public String toString(){

return this.name;

}

 

public int compareTo( Object o ){

Man man = (Man) o;

If(this.age < man.age){

return -1;

}

If( this.age > man.age ){

return 1;

}

return 0;

}

}

批注：

比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

1. 二分法查找

Int[] a = { 1,2,323,23,543,12,59 };

Arrays.sort(a);//使用二分法查找，必须先对数组进行排序

System.out.println( “该元素的索引:”+Arrays.binarySearch(a,12) );

1. 复制

一般用System.arraycopy

1. 填充

Arrays.fill( a,2,4,100 );//将2到4索引的元素替换为100

1. asList( 暂时不讲，讲完容器后再说，事实上用的也不多 )

Int[] a = { 1,2,323,23,543,12,59 };

List<int[]>list =new ArrayList<int[]>();

list = Arrays.asList(a);//将数组转成list对象中的一个元素。

System.out.println( list.get(0)[1] );

多维数组

多维数组可以看成以数组为元素的数组，例如：

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

Int[][] new int[3][];

A[0]= new int[2];

A[1]= new int[4];

A[2]= new int[3];

 

静态初始化：

Int[][] a={

{1,2,3},

{3,4},

{3,5,6,7}

};

System.out.println( a[2][3] );

动态初始化：

Int[][] a=new int[3][];

批注： int[3] [] 后面的 []这个维度不用知名吗?

//a[0]={1,2,3}; //错误，没有声明类型就初始化

A[0]=new int []{1,2};

A[2]=new int[]{2,2};

A[3]=new int[]{2,2,3,4};

System.out.println(a[2][3]);

命令行参数的问题

Public class Test{

Public static void main(String[] args){

For( int i=0;i<args.length;i++ ){

System.out.println( “args[”+i+”]=”+args[i] );

}

}

}

//运行程序Test13_1.java

Java Test lisa  bily  “Mr   Brown”

//输出结果：

Args[0] = lisa;

Args[1] = bily;

Args[2] = Mr Brown

增强for循环

（JDK5.0后增加的，一般用于读取数组或集合中所有的元素！）

　　String[] ss = { “aa”,”bbb”,”ccc”,”ddd” };

　　For( int i=0;i<ss.length;i++ ){

　　　　String temp = ss[i];

　　　　System.out.println( temp );

　　}

: 冒号可以遍历数组里面的元素，左边相当于局部变量，右边相当于要遍历的数组元素

For( String temp : ss ){

System.out.println( temp );

}

 

数组的拷贝

使用java.lang.System类的静态方法

Public static void arraycopy( Object src, int srcPos,Object dest,intdestPos,int length )

可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数从destPos项开始的length个位置

如果源数据数目超过目标数组边界会抛出

IndexOutOfBoundsException异常

数组的拷贝举例

Public class ArrayTest7{

Public static void main(String args[]){

　　String[] s = [ “Mircosoft”,”IBM”,”Sun”,”Oracle”,”Apple” ];

　　String[] sBak = new String[6];

　　System.arraycopy( s,0,sBak,0,s.length );

　　For(int i=0;i<sBak.length;i++){

　　　　System.out.print( sBak[i]+” ” );

　　}

　　System.out.println(  );

Int[][] intArray = { [1,2],[1,2,3],[3,4] };

Int[][] intArrayBak = new int[3][];

System.arraycopy( intArray , 0 ,intArrayBak, 0, intArray.length );

intArrayBak[2][1] = 100;

　　For( int i=0;i<intArray.length;i++ ){

　　　　For( int j=0;j<intArray[i].length;j++ ){

　　　　　　System.out.println( intArray[i][j]+” “ );

　　　　}

　　　　System.out.println();

　　}

}

}

命令行参数

Java应用程序的主方法（程序的入口）

Public static void main ( String args[] ) {...}

Public static void main ( String[] args ) {...}

命令行参数

在启动java应用程序时可以一次性地向应用程序中传递 0~多个参数----命令行参数

命令行参数使用格式：

Java ClassName  lisa “bily” “Mr Brown”

由参数args接收

空格将参数分开

若参数包含空格，用双引号引起来

命令行参数用法举例

Public class Test {

Public static void main{String[] args}{

　　for( int i=0;i<args.length;i++ ){

　　　　System.out.println( “args[”+i+”] = “+args[i] );

　　}

}

}

运行程序Test3_1.java

Java Test  lisa  “bily”  “Mr  Brown”

输出结果：

Args[0] = lisa

Args[1] = bily

Args[2] =Mr Brown

 

获取数组长度：

a.length 获取的二维数组第一维数组的长度,a[0].length 才是获取第二维第一个数组长度。

 

package cn.bjsxt.array2;

import java.util.Arrays;

public class Testarray {

public static void main(String[] args) {
　　// 右键点击Run As，再选择Run Configurations，
　　// 再选择Arguments 在Program arguments:里面写入数组元素（每一行对应一个数组元素） 然后选择run
　　System.out.println(args[0]);
　　int[] a = { 1,2,323,23,543,12,59 };
　　Arrays.sort(a);//使用二分法查找，必须先对数组进行排序
　　System.out.println(a);//打印出来是一个数组
　　// 静态打印数组  通过类名调的
　　// 这里的toString和Object.toString();什么关系，答案是：开放的
　　// Object.toString()这个是普通的
　　System.out.println(Arrays.toString(a));
　　// Arrays.binarySearch(a,12)查找元素12在不在数组对象a里面
　　// 如果是返回索引，如果不是就找不到
　　System.out.println("该元素的索引:"+Arrays.binarySearch(a,12));

　　// 冒泡排序算法
　　int[] value={1,3,42,42,5,52,63,21,42,34};
　　int temp;
　　for(int i=0;i<value.length;i++){
　　　　for(int j=0;j<value.length-1-i;j++){
　　　　　　if(value[j]>value[j+1]){
　　　　　　temp=value[j+1];
　　　　　　value[j+1]=value[j];
　　　　　　value[j]=temp;
　　　　}
　　}
}
　　// 遍历数组
　　for(int e=0;e<value.length;e++) {
　　System.out.print(value[e]+"\t");
　　}
　　/**
　　*
　　0:1
　　1:1
　　2:1
　　3:1
　　4:1
　　5:1
　　冒泡算法
　　int[] value={1,3,42,42,5,52,63,21,42,34};
　　
　　length=10;0-9 计数
　　从0开始 最多需要比较value.length-1趟
　　通过外层循环来控制比较的趟数
　　for(int i=0;i<value.length;i++){
　　　　*
　　　　第value.length趟需要比较value.length-1-i次

　　　　通过内层循环来进行元素之间的比较
　　　　根据它的规律可以看出value.length它的长度减去i它的趟数在减去1
　　　　就等于它第i趟要比较的次数。
　　　　*
　　　　for(int j=0;j<value.length-1-i;j++){
　　　　　　*
　　　　　　需要比较的元素有j+1个,等于它需要比较的次数加1
　　　　　　如果value[j+1]大于value[j]那么久执行语句块
　　　　　　*
　　　　　　if(value[j]>valus[j+1]){
　　　　　　　　将value[j]的值先保存在temp变量中放置value[j]被取代
　　　　　　　　temp=value[j+1];
　　　　　　　　value[j+1]=value[j];
　　　　　　　　value[j]=temp;
　　　　　　}
　　　　}
　　}
　　*/
　　// 二分法查找必须是有序的 从大到小或从小到大排好
　　}
}

package cn.bjsxt.array2;
import java.util.Arrays;
public class TestBinarySearch01{
public static void main(String[] args){
// System.out.println(args[1]);
/**
int[] arr = { 234,245,77,3,543,67,78,95,378,678,205,753,457,2903,340 };
int searchWord = 2903;//所要查找的数
System.out.printf("普通循环查找 %d 的次数是%d",searchWord,genetalLoop(arr,searchWord));
System.out.printf("二分法查找%d的次数是%d",searchWord,binarySearch(arr,searchWord));

int w=0;
w++;
System.out.println("w自增"+w+"");
String[] arr1={"aa","bb","cc","dd"};
// 查找（或搜索） 线性查找
String dest ="dd";
boolean isFlag =true;

for(int i=0;i<arr1.length;i++) {
// equals比较内容是否相等
if(dest.equals(arr1[i])) {
System.out.println("找到了指定的元素，位置为："+i);
isFlag =false;
break;
}
}
// 反向思维 isFlag
if(isFlag) {
System.out.println("很遗憾，没有找到元素");
}
*/

// 数组
int[] arr6 = { 234,245,77,3,543,67,78,95,378,678,205,753,457,2903,340 };
int dest2 = 2903;
// 布尔值判断条件是否为真
boolean isFlag2=true;
// 坐标
int shou = 0;
int mo2 = arr6.length - 1;
// 排序
Arrays.sort(arr6);
// 静态方法通过类名.方法名调用bb方法
System.out.println(TestBinarySearch01.bb(arr6,dest2,shou,mo2,isFlag2));
}
// 二分法while循环
static int bb(int[] arr,int dest2,int shoou,int mo,boolean isFlag2) {
// 循环的次数
int searchCount = 0;
while(shoou<=mo) {
// 每循环1次数自增1
searchCount++;
// 取中间值
int middle =(shoou+mo)/2;
// 如果相等
if(dest2 == arr[middle]) {
System.out.println(arr[middle]);
isFlag2=false;
break;
}
// 如果大于
else if(dest2>arr[middle]) {
shoou=middle+1;
}
// 如果小于
else{
mo=middle-1;
}
}
// 判断它是否为真
if(isFlag2) {
System.out.println("很遗憾，数组元素未找到！");
}
// 返回循环多少次
return searchCount;
}
// 普通循环查找
static int genetalLoop(int[] arr,int searchWord){
//普通的循环法，最少需要比较一次，比如查找1，最多需要比较15次，比如8721
int searchCount =0;
for(int i=0;i<arr.length;i++){
searchCount++;
if(searchWord==arr[i])
break;
}
return searchCount;
}
// 二分法for循环
static int binarySearch(int[] arr11,int searchWordww){
Arrays.sort(arr11); //先对传进来的数组进行排序
// 使用Array.toString打印出排序好的数组
System.out.println( "\n"+Arrays.toString(arr11) );
//二分法查找
int ilndex=0;//相当于指针的东西
// 初始索引的首索引
int iStart=0;
// 初始的末下标
int iEnd=arr11.length-1;
// 循环的次数
int searchCount = 0;
// 布尔值判断条件是否为真
boolean isFale = true;
for(int i=0;i<arr11.length;i++){
// 循环自增
searchCount++;
// 中间坐标
ilndex=(iStart+iEnd)/2;
// 如果大于
if(arr11[ilndex]<searchWordww){
iStart=ilndex+1;
System.out.println( ilndex );
}
// 如果小于
else if( arr11[ilndex]>searchWordww ){
iEnd=ilndex-1;
}
else{
System.out.println( "找到了指定的元素为"+searchWordww+"找到了指定的元素，位置为"+ilndex );
isFale=false;
break;
}
}
if(isFale) {
System.out.println("很遗憾，未找到！");
}
return searchCount;
}
}