java一維數組的定義方式
1. java問題的一維數組的定義及拷貝。。求大神指教。。
替你寫了一下，測試通過
public class Main {
public static void main(String[] args) {
int[] a = new int[10];
for (int i = 0; i < a.length; i++) {
a[i] = (int) (Math.random() * 20);
}
for(int i=0;i<a.length;i++){
System.out.println("a["+i+"]="+a[i]);
}
int[] b = new int[7];
for (int i = 0; i < 3; i++) {
b[i] = (int) (Math.random() * 100);
}
System.array(a,5,b,3,4);
for(int i=0;i<b.length;i++){
System.out.println("b["+i+"]="+b[i]);
}
}
}
輸出結果：
a[0]=15
a[1]=14
a[2]=19
a[3]=18
a[4]=4
a[5]=8
a[6]=14
a[7]=6
a[8]=19
a[9]=10
b[0]=70
b[1]=46
b[2]=55
b[3]=8
b[4]=14
b[5]=6
b[6]=19
2. java中一維數組的概念
一維數組，就是數組，和C語言裡面的數組定義是一樣的，初始化的時候
int a[] = new int [10]; //聲明並定義大小（即分配了指定大小的空間）
int a[] = {1,2,3}; // 聲明並初始化，佔用空間大小是3個int。
類似這樣的就可以了
3. JAVA中如何定義數組類型的數組
你想幹啥。二維數組？它的元素就是一位數組。int[][] arr = new int[3][2];裡面有3個一位數組，每個一位數組有2個元素
4. Java中一維數組定義及初始化 int []a; a[]={1,2,3}; 是錯的，為什麼
如果你熟悉C/C++，Java數組的工作原理與它們不同。Java中的數組是對象，這就意味著與C++中的數組的根本不同.
1、數組不是集合，它只能保存同種類型的多個原始類型或者對象的引用。數組保存的僅僅是對象的引用，而不是對象本身。數組聲明的兩種形式：一、int[] arr; 二、int arr[]; 推薦使用前者，這是一個int數組對象，而不是一個int原始類型。
2、數組本身就是對象，Java中對象是在堆中的，因此數組無論保存原始類型還是其他對象類型，數組對象本身是在堆中的。
4、在數組聲明中包含數組長度永遠是不合法的！如：int[5] arr; 。因為，聲明的時候並沒有實例化任何對象，只有在實例化數組對象時，JVM才分配空間，這時才與長度有關。
5、在數組構造的時候必須指定長度，因為JVM要知道需要在堆上分配多少空間。例：int[] arr = new int[5];
7、一維數組的構造。形如：String[] sa = new String[5]; 或者分成兩句：String[] sa; sa = new String[5];
8、原始類型數組元素的默認值。對於原始類型數組，在用new構造完成而沒有初始化時，JVM自動對其進行初始化。默認值：byte、short、 int、long--0 float--0.0f double--0.0 boolean--false char--'"u0000'。（無論該數組是成員變數還是局部變數）
10、對象類型的數組雖然被默認初始化了，但是並沒有調用其構造函數。也就是說：Car[] myCar = new Car[10];只創建了一個myCar數組對象！並沒有創建Car對象的任何實例！
11、多維數組的構造。float[][] ratings = new float[9][]; 第一維的長度必須給出，其餘的可以不寫，因為JVM只需要知道賦給變數ratings的對象的長度。
12、數組索引的范圍。數組中各個元素的索引是從0開始的，到length-1。每個數組對象都有一個length屬性，它保存了該數組對象的長度。（注意和String對象的length()方法區分開來）
13、Java有數組下標檢查，當訪問超出索引范圍時，將產生運行時異常。注意，這種下標檢查不是在編譯時刻進行的，而是在運行時！也就是說int[] arr = new int[10]; arr[100] = 100; 這么明顯的錯誤可以通過編譯，但在運行時拋出！
Java中的數組中既可以存儲基本的值類型，也可以存儲對象。對象數組和原始數據類型數組在使用方法上幾乎是完全一致的，唯一的差別在於對象數組容納的是引用而原始數據類型數組容納的是具體的數值。在討論關於數組的問題時，一定要先確定數組中存儲的是基本值類型還是對象。特別是在調試程序時，要注意這方面。
5. java:java一維數組和二維數組的定義方法
（一）一維二維數組的定義：
[html]view plain
/*一維數組定義的幾種方法：
*int[]x;
intx[];
二維數組定義的幾種方法：
int[][]y;
inty[][];
int[]y[];
int[]x,y[];//x一維、y二維
int[]x;
int[]y[];
-----------
a:
x[0]=y;//cuo
b:
y[0]=x;//yes
c:
y[0][0]=x;//cuo
d:
x[0][0]=y;//cuo
e:
y[0][0]=x[0];//yes
f:
x=y;//cuo
*/
packagetest;
publicclasstest{
publicstaticvoidmain(String[]args)
{
inta[][]=newint[3][4];
for(intx=0;x<3;x++)
{
for(inty=0;y<4;y++)
System.out.print(a[x][y]);
System.out.println();
}
}
}
控制台輸出結果：
0000
0000
0000
（二）使用二維數組：
[html]view plain
6. java一維數組和二維數組的區別
在java中數組被看成是一個對象
在定義數組時，有兩種定義方法：int[] a 和int a[]；第二種是C/C++對數組定義方式，對於JAVA建議採用第一種定義方式。
總的原則：任何對象在被調用之前必須先被初始化！
1 一維數組的定義
//定義包含三個元素的一維數組
//方法1，先new對象，然後再初始化每個元素
int[] a = new int[3];
a[0] = 1;
a[1] = 2;
a[2] = 3;
方法一要注意的是不能這樣寫：
int[] a = new int[3];
a = {1,2,3};
原因是用new int[3]這種方式創建對象，對象已經被初始化並賦初值為0;可以用下面代碼驗證：
int[] d = new int[3];
for(int i=0;i<d.length;i++){
System.out.println(d[i]);
}
輸入結果是：0 0 0
如果再用a = {1,2,3};來賦值，大家知道常量是不能再被賦值的，不可修改的。
//方法2，直接賦初值來創建對象
int[] b = {1,2,3};
//方法3，new完對象直接初始化
int[] c = new int[]{1,2,3};
方法三要注意的是不能這樣寫： int[] c = new int[3]{1,2,3};
即這種方法不能指定維度，原因：如果指定了數組初始化操作，則不能定義維表達式。
注意：如果用new定義數組時，必須指定其維度，這樣定義是錯誤的: int[] d = new int[];
如果無法確定其元素個數，可以這樣定義:int[] e = {};
2 二維數組的定義
基本與一維數組類似
//定義一個3行5列的二維數組
//方法1，先new對象，然後再初始化每個元素
int[][] a = new int[3][5];
a[0][0]=1;
a[0][1]=2;
a[0][2]=3;
//方法2，直接賦初值來創建對象
int[][] b = {{1,1,1,1,1}, {2,2,2,2,2}, {3,3,3,3,3} };
//方法3，new完對象直接初始化
int[][] a = new int[][] {{1,1,1,1,1}, {2,2,2,2,2}, {3,3,3,3,3} };
7. java 判定一個數組是否是一維數組
一維數組的定義
//定義包含三個元素的一維數組
int[] a = new int[3]; a = {1,2,3};//方法1，先new對象，然後賦值
int[] b = {1,2,3}; //方法2，直接賦值
int[] c = new int[]{1,2,3}; //方法3，new後直接賦值,注意不能制定長度
javascript中： String s = new Array("a","b"); 或者 String s = ["a","b"]; 或者 String s = new Array(); s.push("a");s.push("b");
注意：如果用new定義數組時，必須指定其維度，這樣定義是錯誤的: int[] d = new int[];
如果無法確定其元素個數，可以這樣定義:int[] e = {};
這樣也是錯誤的： int[] c = new int[3]{1,2,3}; 因為初始化時候已經賦值為0；只能為
int[] c = new int[]{1,2,3};
8. java中一維數組的定義及初始化的方法有哪幾種
上面的說法的確不對！
可以這樣理解二維數組，把「一維數組」看做是一種數據類型，二維數組只不過是定義了包含5個數據類型是「一維數組」（和String一樣的一種數據類型）的特殊一維數組。也可以擴展到多維數組。通常會有這種說法java中不存在多為數組，多維數組只是包含n個次維數組類型的元素的一維數組。
從Java中數組定義格式來理解數組的思想。
type[] arrayName;
type arrayName[];
第一種定義格式能更好的幫助我們理解數組，這個格式將 type[] 看做一種數據類型，同於int、String等，是一種引用類型。「type[] arrayName;」定義了一個type[]類型的變數arrayName。從內存中來看，「type[] arrayName;」只是在棧內存中存放了arrayName這個引用類型變數，並沒有指向任何有效的內存。只有在初始化後，才會在堆內存中分配數組元素存儲空間。
同時，這種定義方法，也解釋了為什麼說Java中可以不存在多維數組的說法，因為都是把次維數組看做一個數據類型的緣故。
9. java數組
數組是有序數據的集合，數組中的每個元素具有相同的數組名和下標來唯一地確定數組中的元素。
§5.1一維數組
一、一維數組的定義
type arrayName[];
其中類型(type)可以為Java中任意的數據類型，包括簡單類型組合類型，數組名arrayName為一個合法的標識符，[]指明該變數是一個數組類型變數。例如：
int intArray[];
聲明了一個整型數組，數組中的每個元素為整型數據。與C、C++不同，Java在數組的定義中並不為數組元素分配內存，因此[]中不用指出數組中元素個數，即數組長度，而且對於如上定義的一個數組是不能訪問它的任何元素的。我們必須為它分配內存空間，這時要用到運算符new，其格式如下：
arrayName=new type[arraySize];
其中，arraySize指明數組的長度。如：
intArray=new int[3];
為一個整型數組分配3個int型整數所佔據的內存空間。
通常，這兩部分可以合在一起，格式如下：
type arrayName=new type[arraySize];
例如：
int intArray=new int[3];
二、一維數組元素的引用
定義了一個數組，並用運算符new為它分配了內存空間後，就可以引用數組中的每一個元素了。數組元素的引用方式為：
arrayName[index]
其中：index為數組下標，它可以為整型常數或表達式。如a[3]，b[i](i為整型)，c[6*I]等。下標 從0開始，一直到數組的長度減1。對於上面例子中的in-tArray數來說，它有3個元素，分別為：
intArray[0]，intArray[1]，intArray[2]。注意：沒有intArray[3]。
另外，與C、C++中不同，Java對數組元素要進行越界檢查以保證安全性。同時，對於每個數組都有一個屬性length指明它的長度，例如：intArray.length指明數組intArray的長度。
例5.1
public class ArrayTest{
public static void main(String args[]){
int i;
int a[]=newint[5];
for(i=0;i＜5;i++)
a[i]=i;
for(i=a.length-1;i＞=0;i--)
System.out.println("a["+i+"]="+a[i]);
}
}
運行結果如下：
C:\＞java ArrayTest
a[4]=4
a[3]=3
a[2]=2
a[1]=1
a[0]=0
該程序對數組中的每個元素賦值，然後按逆序輸出。
三、一維數組的初始化
對數組元素可以按照上述的例子進行賦值。也可以在定義數組的同時進行初始化。
例如：
int a[]={1，2，3，4，5};
用逗號(，)分隔數組的各個元素，系統自動為數組分配一定空間。
與C中不同，這時Java不要求數組為靜態(static)。
四、一維數組程序舉例：
例5.2Fibonacci數列
Fibonacci數列的定義為：
F1=F2=1，Fn=Fn-1+Fn-2(n＞=3)
public classFibonacci{
public static void main(String args[]){
int i;
int f[]=new int[10];
f[0]=f[1]=1;
for(i=2;i＜10;i++)
f[i]=f[i-1]+f[i-2];
for(i=1;i＜=10;i++)
System.out.println("F["+i+"]="+f[i-1]);
}
}
運行結果為：
C:\＞java Fibonacci
F[1]=1
F[2]=1
F[3]=2
F[4]=3
F[5]=5
F[6]=8
F[7]=13
F[8]=21
F[9]=34
F[10]=55
例5.3冒泡法排序(從小到大)
冒泡法排序對相鄰的兩個元素進行比較，並把小的元素交到前面。
public class BubbleSort{
public static void main(String args[]){
int i，j;
int intArray[]={30，1，-9，70，25};
int l=intArray.length;
for(i=0;i＜l-1;i++)
for(j=i+1;j＜l;j++)
if(intArray[i]＞intArray[j]){
int t=intArray[i];
intArray[i]=intArray[j];
intArray[j]=t;
}
for(i=0;i＜l;i++)
System.out.println(intArray[i]+"");
}
}
運行結果為：
C:\＞java BubbleSort
-9
1
25
30
70
§5.2多維數組
與C、C++一樣，Java中多維數組被看作數組的數組。例如二維數組為一個特殊的一維數組，其每個元素又是一個一維數組。下面我們主要以二維數為例來進行說明，高維的情況是類似的。
一、二維數組的定義
二維數組的定義方式為：
type arrayName[][];
例如：
int intArray[][];
與一維數組一樣，這時對數組元素也沒有分配內存空間，同要使用運算符new來分配內存，然後才可以訪問每個元素。
對高維數組來說，分配內存空間有下面幾種方法：
1直接為每一維分配空間，如：
int a[][]=new int[2][3];
2從最高維開始，分別為每一維分配空間，如：
int a[][]=new int[2][];
a[0]=new int[3];
a[1]=new int[3];
完成1中相同的功能。這一點與C、C++是不同的，在C、C++中必須一次指明每一維的長度。
二、二維數組元素的引用
對二維數組中每個元素，引用方式為：arrayName[index1][index2] 其中index1、index2為下標，可為整型常數或表達式，如a[2][3]等，同樣，每一維的下標都從0開始。
三、二維數組的初始化
有兩種方式：
1直接對每個元素進行賦值。
2在定義數組的同時進行初始化。
如：int a[][]={{2，3}，{1，5}，{3，4}};
定義了一個3×2的數組，並對每個元素賦值。
四、二維數組舉例：
例5.4矩陣相乘
兩個矩陣Am×n、Bn×l相乘得到Cm×l，每個元素Cij=�aik*bk (i=1..m，n=1..n)
public class MatrixMultiply{
public static void main(String args[]){
int i，j，k;
int a[][]=new int[2][3];
int b[][]={{1，5，2，8}，{5，9，10，-3}，{2，7，-5，-18}};
int c[][]=new int[2][4];
for(i=0;i＜2;i++)
for(j=0;j＜3;j++)
a[i][j]=(i+1)*(j+2);
for(i=0;i＜2;i++){
for(j=0;j＜4;j++){
c[i][j]=0;
for(k=0;k＜3;k++)
c[i][j]+=a[i][k]*b[k][j];
}
}
System.out.println("\n***MatrixA***");
for(i=0;i＜2;i++){
for(j=0;j＜3;j++)
System.out.print(a[i][j]+"");
System.out.println();
}
System.out.println("\n***MatrixB***");
for(i=0;i＜3;i++){
for(j=0;j＜4;j++)
System.out.print(b[i][j]+"");
System.out.println();
}
System.out.println("\n***MatrixC***");
for(i=0;i＜2;i++){
for(j=0;j＜4;j++)
System.out.print(c[i][j]+"");
System.out.println();
}
}
}
其結果為：
C:\＞java MatrixMultiply
for(j=0;j＜4;j++)
System.out.print(c[i][j]+"");
System.out.println();
}
}
}
其結果為：
C:\＞java MatrixMultiply
***MatrixA***
2 3 4
4 6 8
***MatrixB***
1 5 2 8
5 9 10 -3
2 7 -5 -18
***MatrixC***
25 65 14 -65
50 130 28 -130
如果你學過線性代數，應該可以比較好地理解多維數組。
多維數組和矩陣結合緊密。
a[i][j]就是第i-1行的第j-1列的元素，因為下標是從0開始的。
比如：
一個數組：1 2 3
4 5 6
a[0][0]=1 a[0][1]=2 a[0][2]=3
a[1][0]=3 a[1][1]=5 a[1][2]=6
我推薦你看幾本書：
1.Thinking in Java
2.Java 2 核心技術
3.Java2實用教程
4.面向對象程序設計與java語言
10. 怎樣用java定義一個int數組
數組：是一組相關變數的集合數組是一組相關數據的集合，一個數組實際上就是一連串的變數，數組按照使用可以分為一維數組、二維數組、多維數組
數據的有點不使用數組定義100個整形變數：int i1;int i2;int i3
使用數組定義 int i[100];
數組定義：int i[100];只是一個偽代碼，只是表示含義的
（1）一維數組
一維數組可以存放上千萬個數據，並且這些數據的類型是完全相同的，
使用java數組，必須經過兩個步驟，聲明數組和分配內存給該數組，
聲明形式一
聲明一維數組：數據類型 數組名[]=null;
非配內存給數組：數組名=new 數據類型[長度];
聲明形式二
聲明一維數組：數據類型 [] 數組名=null;
（2）java數據類型分為兩大類
1.基本數據類型
int、long操作的時候本身就是具體的內容
引用數據類型：數組、類、介面
引用傳遞的就是一個內存的使用權，一塊內存空間，可能有多個人同時使用
2.事例聲明數組
