初始化boolean矩阵_矩阵运算——数组

原标题：矩阵运算——数组

数组概述和特点

数组的定义：数组是相同类型数据的有序集合. 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

数组的四个基本特点：

1.其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

2.其元素必须是相同类型,不允许出现混合类型。

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

4.数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

创建数组和初始化

声明(一维数组的声明方式有两种)

type[] arr_name;(推荐使用这中方式)

type arr_name[];

注：

1.声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。因此，声明数组时不能指定其长度(数组中元素的个数)，例如： int a[5]; //非法

2.声明一个数组的时候并没有数组被真正的创建。

3.构造一个数组，必须指定长度。

构建数组：

创建基本类型一维数组示例：

public class Test{

public static void main(String args[]){

int[] s =null;// 1

s =new int[10];//2

for (int i=0; i<10; i++ ) {

s[i] =2*i+1;

System.out.println(s[i]);

}//3

}

}

class Man{

private int age;

private int id;

public Man(int id,int age) {

super();

this.age = age;

this.id = id;

}

}

public class AppMain {

public static void main(String[] args) {

Man[] mans;

mans =new Man[10];//1

Man m1 =new Man(1,11);

Man m2 =new Man(2,22);//2

mans[0]=m1;

mans[1]=m2;//3

}

}

初始化创建引用类型一维数组示例：

静态初始化

除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] a = {1,2,3};

Man[] mans = {

new Man(1,1),

new Man(2,2)

};

动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

、

int[] a =new int[2];

a[0]=1;

a[1]=2;

数组的默认初始化：

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int a[] =new int[2];//0,0

boolean [] b =new boolean[2];//false,false

String[] s =new String[2];//null, null

数组的界限

1.下标的合法区间：[0, length-1]

1定义 4特点 3初始化方式！

数组常见操作

数组的拷贝

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","Sun","Oracle","Apple"};

String[] sBak =new String[6];

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

java.util.Arrays

1.打印数组

int[] a = {1,2};

System.out.println(a); //[I@35ce36

System.out.println(Arrays.toString(a)); //[1, 2]

数组排序

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

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

Arrays.sort(a);

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

结果：

[1, 2, 323, 23, 543, 12, 59]

[1, 2, 12, 23, 59, 323, 543]

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

1234567891011121314151617181920212223242526272829303132public 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.ageman.age){return 1;}return 0;} }

2. 二分法查找

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

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

System.out.println("该元素的索引："+Arrays.binarySearch(a, 12));

3. 复制

一般用System. arraycopy

4. 填充

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

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

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

List list = new ArrayList();

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

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

多维数组

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

静态初始化

int[][] a = {

{1,2,3},

{3,4},

{3,5,6,7}

};

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

动态初始化：

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

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

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

a[1]=new int[]{2,2};

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

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

获取数组长度：

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

附录

(面试前复习一下！！)

冒泡排序

public class Test {

public static void main(String[] args) {

int[] values = {3,1,6,2,9,0,7,4,5,8 };

sort(values);

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

}

public static void sort(int[] values) {

int temp;

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

for (int j =0; j < values.length -1- i ; j++) {

if (values[j] > values[j +1]) {

temp = values[j];

values[j] = values[j +1];

values[j +1] = temp;

}

}

}

}

}

二分法查找

import java.util.Arrays;

public class TestBinarySearch {

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 =6780;//所要查找的数

int searchCount =0;//循环的次数

System.out.printf("普通循环查找%d的次数是%d",searchWord,genetalLoop(arr,searchWord));

System.out.printf("二分法查找%d的次数是%d",searchWord,binarySearch(arr,searchWord));

}

static int genetalLoop(int[] arr,int searchWord){

//普通的循环法，最少需要比较一次，比如查找1，最多需要比较15次，比如8721

int searchCount =0;

for(int i=0;i

searchCount++;

if (searchWord==arr[i])

break;

}

return searchCount;

}

//int[] arr = {234,245,77,3,543,67,78,95,378,678,205,753,457,2903,340};

static int binarySearch(int[] arr,int searchWord){

Arrays.sort(arr);//先对传进来的数组进行排序

System.out.println("\n"+Arrays.toString(arr));

//二分法查找

int iIndex=0;//相当于指针的东西

int iStart=0;

int iEnd=arr.length-1;

int searchCount =0;

for(int i=0;i

searchCount++;

iIndex = (iStart+iEnd)/2;

if(arr[iIndex]

System.out.println("aa");

iStart = iIndex;

}else if(arr[iIndex]>searchWord){

System.out.println("bb");

iEnd = iIndex;

}else{

break;

}

}

return searchCount;

}

}

命令行参数的问题

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

eclipse里如何使用？

增强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);

}

1.完成课堂上老师的代码上机作业

2.利用二维数组实现：n阶矩阵的加法、乘法操作。(大家可以使用double类型，int容易产生溢出！) 难度较高

public class TestMatrix {

public static void main(String[] args){

int[][] a = {

{2,2,4,6},

{4,5,6,8},

{1,2,32,3},

{1,2,3,4}

} ;

int[][] b = {

{80,2,4,7},

{6,5,6,2},

{9,7,2,3},

{9,3,2,3}

} ;

mutiple(a,b);

}

static void mutiple(int[][] a,int[][] b){

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

for(int i=0;i

for(int j=0;j

for(int k=0;k