原标题:矩阵运算——数组
数组概述和特点
数组的定义:数组是相同类型数据的有序集合. 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.
数组的四个基本特点:
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