javaarray
① 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一樣了
你要是不給我分,我也徹底無語了，我可是認真敲出來的答案
② java里的array是什麼意思
Java中沒有array，只有Arrays這個類
此類包含用來操作數組（比如排序和搜索）的各種方法。此類還包含一個允許將數組作為列表來查看的靜態工廠。
③ 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.鏈頭不變
④ java array
在一個死循環里while(true),輸一個數字,判斷一下是不是99,不是就往數組的末尾加,是就break,然後輸出整個數組,試試吧,應該能做出來的.輸入是System.in
⑤ java 數組
對與你的這個程序演算法也沒什麼復雜的。我也就不用解釋了。關於你提出的問題我說一下：
1. 修改array2時array1當然要發生變化了。之所以你對這個有疑問，是你對java中的數據類型還沒理解。在java中有兩中數據類型，值類型和引用類型。像一些基本的數據類型如：int ,float,double,byte等都是值類型，而String,還有『類』都是引用類型，其中數組也是引用類型。
array2=array1; 這句話就是把array1的首地址賦值給array2，此時array1和array2所指向的是同一塊類存單元。array2對這塊內存的修改也會反映在array1上了。
同樣的道理，當向一個函數傳值時，如果函數的形參是一個值類型的數據，則在傳參數時把實參的內容拷貝一份放到形參裡面，之後形參在函數相當於一個局部變數，它在函數中做的一切動作都不會影響到實參的內容。
而如果函數的形參是一個引用類型，當向它傳值時，就是把實參的地址傳給形參，而不是把它的內容傳給形參。這時候形參有了實際參數的內存地址，那麼在函數中形參的改變也會反應到實際參數中來，你可以做下列實驗：
//test1.java
class test1
{
public static void main(String [] args)
{
int [] b={9,8,7,6,5,4,3,2,1,0};
int c=10;
test2.amend(b);
test2.print(b);//輸出：0 1 2 3 4 5 6 7 8 9說明b的值被改了。
System.out.println(""); //換行
test2.amend1(c);
System.out.println(c); //輸出：10 說明c的值並沒有被改為20
}
}
class test2
{
public static void amend(int [] a) //引用傳遞
{
for(int i=0;i<a.length;i++)
a[i]=i;
}
public static void print(int [] a)
{
for(int i=0;i<a.length;i++)
System.out.print(a[i]+" ");
}
public static void amend1(int a)
{
a=20;
}
}
引用就相當於c語言裡面的指針，不知道你學過c語言沒有。如果學過，就應該很容易理解的。java中沒有指針的概念，在java中是不允許直接操作變數的內存地址的。
int a=10;
int b=a; //這里僅僅是把a的值，也就是10拷貝一份再賦給變數b。a和b在內存上是沒有任何聯系的。
如果Student是一個類，那麼：
Student stu1=new Student(); //學生1
Student stu2=stu1; //把學生1的引用賦給學生2這時候stu2的操作就會反映到stu1上。
參考下面的例子：
class test1
{
public static void main(String [] args)
{
Student stu1=new Student("張三",18); //建立一個學生變數，並且初始化為"張三" ,18歲 Student stu2=stu1; //把學生stu1的引用賦給學生stu2
stu1.print(); //輸出：名字:張三 年齡:18
stu2.print(); //輸出：名字:張三 年齡:18
//把學生stu2的名字改成"李四" 20歲
stu2.name="李四";
stu2.age=20;
stu1.print(); //輸出名字:李四 年齡:20
stu2.print(); //輸出名字:李四 年齡:20
}
}
class Student
{
String name; //學生的名字
int age; //學生的年齡
Student(String name,int age)
{
this.name=name; //給名字賦值
this.age=age; //給年齡賦值
}
void print() //輸出學生的名字和年齡
{
System.out.println("名字:"+name+" 年齡:"+age);
}
}
//可以看到，我改了stu2的名字和年齡，但是stu1學生的名字和年齡也改了。這就是引用的效果。
2.第二個問題：This method has a constructor name
這句話的意思說，"這個方法有一個構造函數名字"
為什麼會出現這樣的提示呢？是因為你定義的類的名字是：printArray，而這個類默認有一個構造函數它的名字是和類名相同的。而且構造函數是沒有返回值的。
而你在類裡面有定義了一個public 的靜態的成員方法。
它的名字和你的構造函數的名字是一樣的。如果你把static void 都去掉的話，也就是說變成這種形式：
public printArray(int [] array)
{
}
那麼這時系統就會把它當作是類的構造函數了，但是你這里函數的形式是：
public static void printArray(int [] array)
{
}
因為有返回值所以，系統把它當作是類的成員函數了，但是它又是與構造函數的名字相同的，所以就出現了你上面的警告了。雖然沒有報錯，但還是希望類的成員函數不要與類的名字相同，以免帶來不必要的麻煩。
我的回答也只有這些了，相信你對java裡面的數據類型也有了一個了解了吧，如果還有不懂的話，上網路去吧。。
⑥ 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);
}
} 記得採納哦
⑦ 請問Java中的Array是怎麼使用的
Array就是陣列，磁碟陣列模式是把幾個磁碟的存儲空間整合起來，形成一個大的單一連續的存儲空間。NetRAID控制器利用它的SCSI通道可以把多個磁碟組合成一個磁碟陣列。簡單的說，陣列就是由多個磁碟組成，並行工作的磁碟系統。需要注意的是作為熱備用的磁碟是不能添加到陣列中的。
⑧ java中arrays的用法
如果你問的是API的話，要注意，Java中是區分大小寫的，不存在arrays這么個類，而是Arrays，
並且全稱是java.util.Arrays，其文檔可在 http://download.oracle.com/javase/6/docs/api/ 參考，搜索Arrays你就找到了，不要懼怕英文，耐心看一下就搞明白了。
如果是問的數組(array)，那麼：
第一，在Java中，數組是一種專門的類型，它是有序數據的集合，數組中的每個元素的數據類型都是相同的。
第二，對元素的確定是由數組名和它的下標實現的，這是和C/C++中的一樣的，比如a[0]代表數組a的第一個元素，a[1]代表數組a的第二個元素，依次類推。
第三，得說說數組的聲明方法，Java的數組聲明採用與C語言類似, 數組可分為一維數組和多維數組。聲明形式為： type arrayName [] [[]...]; 或：type [] [[]...] arrayName; 後邊這種方式是Java比較獨特的地方, 體現了Java的純面向對象的特徵。
第四，Java數組聲明中，不需要指明數組大小，這是因為數組聲明並未為數組元素分配存儲單元，要為數組元素分配存儲單元，必須顯示使用new運算符實現，這里就和C/C++有很大不同了。格式是： arrayName[][[]...] = new type [Size1][[Size2]...];
第五，聲明數組與為數組分配存儲單元兩部分，可以合在一起；上面舉例的就是和在一起的形式。如果要分開，就是寫兩成兩句：int numbers[]; numbers = new int[10]; 這看起來和C++很相似。
第六，對已經分配了存儲空間的數組(由new運算符實現)，就可以對數組中的每一個元素引用。下標是放在數組名後面[]中的，通過對下標的操作來引用元素。我們可以賦值給元素，也可以使用元素的值，主要下標是從0開始的。
第七，Java中，對於每一個數組，都有一個屬性length，來指明數組的長度，這對於寫程序就很方便了。int count[] = new int [10]; 包括count[0] count[1] ... count[9] 那麼 count.length = 10
第八，在聲明數組時，也可以同時對數組進行初始化。它的一維形式如下：
type arrayName[] = {Value1, Value2, ... , ValueN};
例如：
float myf[] = {1,2,3,4,5,6}
int myint[][]={{1,2,3},{4,5,6}};
//int myint[][]=new myint[2][3];
與C或C++語言不一樣，Java對數組元素的下標要進行越界檢查，以確保數據的安全。
記住這8條，我相信你對數組就基本都掌握了。
好了，希望對你有所幫助，有問題隨時聯系我:)
⑨ 關於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;
}
}
⑩ 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語言