java數組

1. java中的數組

·數組是可以保存一組數據的一種數據結構，它本身也會佔用一個內存地址，因此數組是引用類型 ·一個數組中只能保存一種類型的數據，可以保存基本類型，也可以保存Object。一個int,一個String是不能同時保存在一個數組內的(如果是對象型數組，注意存放的每一個對象都必須被實例化)。 ·數組的長度規定好即固定，無論其保存的數據是否填滿數組 ·數組一旦定義好就不可以修改長度，如果要修改就必須重新定義一個新數組或者引用其他的數組，因此數組的靈活性較差 ·數組擁有邊界檢查，嘗試獲取不在數組范圍內的值時，會拋出異常

2. Java中數組的定義與使用方法

Java中數組的定義與使用方法:
1、數組的定義
語法有兩種：
type arrayName[];
type[] arrayName;
type 為Java中的任意數據類型，包括基本類型和組合類型，arrayName為數組名，必須是一個合法的標識符，[ ] 指明該變數是一個數組類型變數。
例如：
int demoArray[];
int[] demoArray;
這兩種形式沒有區別，使用效果完全一樣，讀者可根據自己的編程習慣選擇。
注意：Java在定義數組時並不為數組元素分配內存，因此[ ]中無需指定數組元素的個數，即數組長度。而且對於如上定義的一個數組是不能訪問它的任何元素的，開發者必須要為它分配內存空間，這時要用到運算符new，其格式如下：
arrayName=new type[arraySize];
其中，arraySize 為數組的長度，type 為數組的類型。如：
demoArray=new int[3];//為一個整型數組分配3個int 型整數所佔據的內存空間。
2、數組的初始化
可以在聲明數組的同時進行初始化（靜態初始化），也可以在聲明以後進行初始化（動態初始化）。例如：
// 靜態初始化
// 靜態初始化的同時就為數組元素分配空間並賦值
int intArray[] = {1,2,3,4};
String stringArray[] = {"", "", "網路知道"};
// 動態初始化
float floatArray[] = new float[3];
floatArray[0] = 1.0f;
floatArray[1] = 132.63f;
floatArray[2] = 100F;

3、數組的使用：
每個數組都有一個length屬性來指明它的長度，例如 intArray.length 指明數組 intArray 的長度。
【示例】寫一段代碼，要求輸入任意5個整數，輸出它們的和。
import java.util.*;
public class Demo {
public static void main(String[] args){
int intArray[] = new int[5];
long total = 0;
int len = intArray.length;

// 給數組元素賦值
System.out.print("請輸入" + len + "個整數，以空格為分隔：");
Scanner sc = new Scanner(System.in);
for(int i=0; i<len; i++){
intArray[i] = sc.nextInt();
}

// 計算數組元素的和
for(int i=0; i<len; i++){
total += intArray[i];
}

System.out.println("所有數組元素的和為：" + total);
}
}

運行結果：
請輸入5個整數，以空格為分隔：10 20 15 25 50
所有數組元素的和為：120

3. java中數組的定義

//指定長度為10
String [] arr = new String[10];
//兩種沒什麼區別，只是上面可讀性比較好
String arr[] = new String[10];
//直接初始化數組
String[] arr = {"a","b"};
//先定義一個數組
String [] arr = null;
//賦值數組的第一個值
arr[0] = "a";

4. JAVA數組

這個程序為了易刪除，並沒有採用數組，而採用了雙向鏈表

鏈表中的元素是結點Kid，Kid有一個左結點，一個右結點，左結點指向上一個Kid，右結點指向下一個Kid。這些在構造函數中完成的，其中first是第一個結點，last是最後一個結點。

這樣就把500個孩子串成一條鏈，並且這是一個環狀的鏈，你畫個圖就明白了。

這樣刪除起來就方便了，如果要刪一個結點

這個結點的左結點的右結點=這個結點的結節點

這個結點的右結點的左結點=這個結點的結節點

---------------------------------------------------------------

具體講講add的演算法，你准備一張紙，在上面畫就能理解：

每個孩子的編號id設為count，然後把這個孩子往鏈表裡添

如果目前沒有鏈表，即孩子數量為0，則創建鏈表，鏈頭是first，鏈尾是last

1.添加一個孩子，這個孩子是這個鏈表的鏈頭first，也是鏈尾last，即first=last=k;

2.由於沒有其他結點，這個結點的左結點就是自己，右結點也是自己，即k.left=k.right=k;

如果目前已經有鏈表，則

1.添加新結點到鏈尾的下一個，即last.right=k;，

2.新結點的左結點是之前的鏈尾，即k.left=last;

3.由於是一個環形的鏈，新結點的右結點鏈頭k.right=first;

4.由於是一個環形的鏈，鏈頭的左結點是新結點first.left=k;

5.新結點是新鏈的鏈尾last=k;

6.鏈頭不變

5. 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語言

6. 關於JAVA數組

運行後信息輸出到C:\123.txt這個文件,有不明白就 Email: [email protected]

Test.java

import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.text.DecimalFormat;

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
PrintWriter pw = null;

/**
* 1 表示把輸出到c:\123.txt 其餘情況輸出到控制台
*
* @param i
* @return
*/
int method = 1;
pw = createPW(method);

/**
* 創造一個二維數組，數組的行代表層數，數組的列代表房間號。
*/
float[][] a = create2DimArray(30, 20);
/**
* 用一個嵌套循環，把基礎房間價格放在每層的每間房裡。
*/
setDefualt(a, 150);
/**
* 用一個巢狀循環(不知道什麼是巢狀循環,用for嵌套代替吧)，把每層每間的基礎價格顯示（列印）出來。
*/
pw.write("初始房間價格列表：");
pw.write("\r\n");
print2DimArray(a, pw);

pw.write("============================================================================分割線================================================================");
pw.write("\r\n");
/**
* 用一個嵌套循環，根據上面的BCDE的條件來調整每層的房間價格。
*
* B.靠沙灘（房間6~11）+$100
*
* C.從側面能看到海的房間每間（房間1~5,12~16）+$50
*
* D.四個角落的大房間（房間1,6,11,16）每個+$100
*
* E頂層（30層）+$100
*/
modifyPrice(a);

/**
* .用一個嵌套循環，把每層每間的調整過後的房價顯示出來。形式是，房間號FRR，和價格 $XXX.XX
*/
pw.write("更新後房間價格列表：");
pw.write("\r\n");
print2DimArray(a, pw);

pw.flush();

/**
* 如果輸出到文件流的話，還要關閉對應的輸出流，控制台輸出就不用關閉了
*/
if (method == 1) {
pw.close();
}

}

/**
* 1 表示把輸出到c:\123.txt 其餘情況輸出到控制台
*
* @param i
* @return
*/
private static PrintWriter createPW(int i) {
PrintWriter pw = null;
switch (i) {
case 0: {
pw = new PrintWriter(System.out);
break;
}
case 1: {
try {
pw = new PrintWriter("c:\\123.txt");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

break;
}
default: {
pw = new PrintWriter(System.out);
break;
}
}

return pw;
}

/**
* 用一個嵌套循環，根據上面的BCDE的條件來調整每層的房間價格。
*
* B.靠沙灘（房間6~11）+$100
*
* C.從側面能看到海的房間每間（房間1~5,12~16）+$50
*
* D.四個角落的大房間（房間1,6,11,16）每個+$100
*
* E頂層（30層）+$100
*/
private static void modifyPrice(float[][] a) {
for (int i = 0, k = a.length; i < k; i++) {
float[] b = a[i];
for (int m = 0, n = b.length; m < n; m++) {
b[m] = modifyPrice(b[m], i, m);
}
}
}

private static float modifyPrice(float value, int i, int m) {
int a = i + 1;
int b = m + 1;
if (b > 6 && b <= 11) {
value += 100;
} else if ((b > 1 && b <= 5) || b > 12 && b < 16) {
value += 50;
} else if (b == 1 || b == 16) {
value += 150;
} else if (b == 6 || b == 11) {
value += 200;
}

if (a == 30) {
value += 100;
}
return value;
}

/**
* 用一個巢狀循環(不知道什麼是巢狀循環,用for嵌套代替吧)，把每層每間的基礎價格顯示（列印）出來。
*/
private static void print2DimArray(float[][] a, PrintWriter pw) {
if (pw == null) {
print2DimArray(a);
}
String s;
float[] b;
DecimalFormat df = new DecimalFormat(".00");
for (int i = 0, k = a.length; i < k; i++) {
b = a[i];
for (int m = 0, n = b.length; m < n; m++) {
s = "房間號:" + (i < 9 ? " " : " ") + (i + 1)
+ (m < 9 ? "0" : "") + (m + 1) + ",";
s += "價格$" + df.format(b[m]) + " ";
pw.write(s);
}
pw.write("\r\n");
}
}

/**
* 用一個巢狀循環(不知道什麼是巢狀循環,用for嵌套代替吧)，把每層每間的基礎價格顯示（列印）出來。
*/
private static void print2DimArray(float[][] a) {
for (int i = 0, k = a.length; i < k; i++) {
float[] b = a[i];
for (int m = 0, n = b.length; m < n; m++) {
System.out.printf("房間號:" + (i < 9 ? " " : " ") + "%d"
+ (m < 9 ? "0" : "") + "%d,價格:$%#.2f ", i + 1, m + 1,
b[m]);
}
System.out.println("");
}
}

/**
* 用一個嵌套循環，把基礎房間價格放在每層的每間房裡。
*/
private static void setDefualt(float[][] a, float value) {
for (int i = 0, k = a.length; i < k; i++) {
float[] b = a[i];
for (int m = 0, n = b.length; m < n; m++) {
b[m] = value;
}
}
}

/**
* 創造一個二維數組，數組的行代表層數，數組的列代表房間號。
*/
private static float[][] create2DimArray(int i, int j) {
float[][] a = new float[i][i];
return a;
}

}

7. Java數組

public static void main(String[] args) {
int[] arr=new int[10];
for(int i=0;i<arr.length;i++){
arr[i]=(int)(Math.random()*10);
}
for(int n :arr){
System.out.println(n);
}
int arrMax=0,arrMin=0;
arrMax=arr[0];
arrMin=arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i]>arrMax){arrMax=arr[i];}
if(arr[i]<arrMin){ arrMin=arr[i];}
}
System.out.println("最大值---"+arrMax+"\n"+"最小值---"+arrMin);

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

if(arr[j]>arr[j+1]){
int num=arr[j];
arr[j]=arr[j+1];
arr[j+1]=num;
}
}
}
for(int n :arr){
System.out.println(n);
}

} 記得採納哦

8. java數組(初學者）

當你建立數組 a[] b[] 後 各自分配了一個內存地址, 假設a[] 的是A(這是段0和1組成的代碼) A里邊存放的是100,200,300
當你在程序中調用a[],程序會先找到A,然後用里邊的東西所以例如:a[0]=100
b[]的是B(同上)
B里存放的是 10,11,12,13,14,15,16
b[0]=10
當你b=a時,b的內存地址不再指向B而是指向A了,於是它里邊的東西就跟a[]的一樣了,故b[0]=100了
比喻:
a,b都是鑰匙
a可以打開A房間 里邊放了 100...
b可以打開B房間 里邊放了10,11...
現在改造了 b=a
就是把b要是改成了跟a一樣的鑰匙,所以它不能再開B房間,只能開A房間，大小內容跟a一樣了

你要是不給我分,我也徹底無語了，我可是認真敲出來的答案

9. JAVA數組解決

兩個for循環取二維數組的值，取數值的第一個值，生成一個數組，然後冒泡排序

10. Java數組有哪些用法

數組：是一組相關變數的集合數組是一組相關數據的集合，一個數組實際上就是一連串的變數，數組按照使用可以分為一維數組、二維數組、多維數組

數據的有點不使用數組定義100個整形變數：int i1;int i2;int i3

使用數組定義 int i[100];

數組定義：int i[100];只是一個偽代碼，只是表示含義的（1）一維數組

一維數組可以存放上千萬個數據，並且這些數據的類型是完全相同的，使用java數組，必須經過兩個步驟，聲明數組和分配內存給該數組，聲明形式一聲明一維數組：數據類型 數組名[]=null;非配內存給數組：數組名=new 數據類型[長度];聲明形式二聲明一維數組：數據類型 [] 數組名=null;

（2）java數據類型分為兩大類1.基本數據類型int、long操作的時候本身就是具體的內容引用數據類型：數組、類、介面

引用傳遞的就是一個內存的使用權，一塊內存空間，可能有多個人同時使用

2.事例聲明數組