java數組屬性

A. java封裝屬性 數組

這段代碼也是醉了，你存入list應該是一個對象Person，

而你給一組數組賦值我也是沒搞懂你的意思，

你這樣寫代碼能存入list集合的只是一個Person對象，而你給對象欄位賦值的語句就只有p.name = s.next();p.pingjun = (rr / (a.length - 1)) + "";，只有2個屬性付了值，其他的沒有賦值是null；

一個構造器給Person的數組賦值？一個長度20的字元空數組，然後你給w數組賦值，那麼你這樣子賦值你以為可以影響到Person的值？w[i] = u + "";這句代碼，與Person對象沒半毛錢關系，對象引用都沒有怎麼賦值，

你最後列印的是Person對象的欄位，而你存入一個空數組，然後把string類型欄位的原始屬性給一個數組，Person(String r[]) {
r[1] = this.yuwen;
r[2] = this.shuxve;
r[3] = this.wuli;
r[4] = this.waiyu;
r[5] = this.huaxve;

}

這有啥用，我很好奇你這個r數組也不是類中的欄位，你給他付了null的值，你給他傳入的是長度20的數組，後面還有15個長度呢，不管這個，關鍵是這個數組啥用也沒有除了浪費內存

下面這段代碼中list.add(p);，你把Person 對象存入list，此時的Person 對象被賦值的就只有2個欄位，你給w，r數組的值無法影響到Person 對象，且這個方法執行完畢後，也會被清理掉因為沒有被引用到

這個時候可以回答你的問題了，為什麼你輸入的分數顯示都是null：

因為他都沒被賦值到Person 的成員變數上面，沒被賦值的成員變數的String值是null，容易你列印Person 未被賦值的成員變數的值，就是null；

String r[] = new String[a.length - 2];

String w[] = new String[20];
int rr = 0;
Person p = new Person(w);

p.name = s.next();

for (int i = 1; i < a.length - 1; i++) {
int u = s.nextInt();
w[i] = u + "";
r[i - 1] = u + "";
rr += u;
}
p.pingjun = (rr / (a.length - 1)) + "";
list.add(p);

B. java中數組有沒有length()方法string沒有lenght()方法

java中數組是沒有length()方法的，只有length屬性，數組array.length返回的是該數組的長度。

字元串String是有length()方法的，str.length()返回的是該字元串的長度。

(2)java數組屬性擴展閱讀

java數組常用方法：

1、聲明一個數組

String[] aArray = new String[5]；

String[] bArray = {"a","b","c", "d", "e"}；

String[] cArray = new String[]{"a","b","c","d","e"}；

2、列印一個數組

String[] aArray = new String[5]；

String[] bArray = {"a","b","c", "d", "e"}；

String[] cArray = new String[]{"a","b","c","d","e"}；

3、根據數組創建ArrayList

String[] stringArray = { "a", "b", "c", "d", "e" }；

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray))；

System.out.println(arrayList)；

4、判斷數組內部是否包含某個值

String[] stringArray = { "a", "b", "c", "d", "e" }；

boolean b = Arrays.asList(stringArray).contains("a")；

System.out.println(b)；

5、連接兩個數組

int[] intArray = { 1, 2, 3, 4, 5 }；

int[] intArray2 = { 6, 7, 8, 9, 10 }；

int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2)；

6、聲明一個內聯數組

method(new String[]{"a", "b", "c", "d", "e"})

String常用方法：

1、求字元串某一位置字元

charAt(int index)返回字元串中指定位置的字元；注意字元串中第一個字元索引是0，最後一個是

length()-1。

例如：

String str = new String("asdfzxc")；

char ch = str.charAt(4)；//ch = z

2、提取子串

用String類的substring方法可以提取字元串中的子串，該方法有兩種常用參數：

1)substring(int beginIndex)該方法從beginIndex位置起，從當前字元串中取出剩餘的字元作為一

個新的字元串返回。

2)substring(int beginIndex, int endIndex)該方法從beginIndex位置起，從當前字元串中取出到

endIndex-1位置的字元作為一個新的字元串返回。

例如：

String str1 = new String("asdfzxc")；

String str2 = str1.substring(2)；//str2 = "dfzxc"

String str3 = str1.substring(2,5)；//str3 = "dfz"

3、字元串比較

1)compareTo(String anotherString)該方法是對字元串內容按字典順序進行大小比較，通過返回的

整數值指明當前字元串與參數字元串的大小關系。若當前對象比參數大則返回正整數，反之返回負

整數，相等返回0。

2)compareToIgnore(String anotherString)與compareTo方法相似，但忽略大小寫。

3)equals(Object anotherObject)//比較當前字元串和參數字元串，在兩個字元串相等的時候返回

true，否則返回false。

4)equalsIgnoreCase(String anotherString)//與equals方法相似，但忽略大小寫。

例如：

String str1 = new String("abc")；

String str2 = new String("ABC")；

int a = str1.compareTo(str2)；//a>0

int b = str1.compareToIgnoreCase(str2)；//b=0

boolean c = str1.equals(str2)；//c=false

boolean d = str1.equalsIgnoreCase(str2)；//d=true

4、字元串連接

concat(String str)將參數中的字元串str連接到當前字元串的後面，效果等價於"+"。

例如：

String str = "aa".concat("bb").concat("cc")；

相當於String str = "aa"+"bb"+"cc"；

C. java數組有那些屬性

length屬性，表示數組的長度。即數組中元素的個數

D. Java中定義類的一個屬性為數組。

class Shuzu {
String word;
// 不知道你要什麼類型的數組,所以給你定一個一個Object類型的呵呵
Object[] num;

public Shuzu(int n) {
this.num = new Object[n];
}

public void xs() {
System.out.println(word);
// 循環列印數組中的內容
for (int i = 0; i < num.length; i++) {
// 如果數組不存滿值,剩下的會打成null的!
System.out.println(num[i]);
}
System.out.println("最後列印數組長度" + num.length);
}
}

public class test58 {
public static void main(String args[]) {
Shuzu array = null;
//這里傳入的"10"是你想設置的數組的長度!在
array = new Shuzu(10);
array.word = "數組為:";
array.num[0] = "什麼阿";
array.num[1] = "nihao";
array.num[2] = "#%*#";
array.num[4] = "43開始列印2";
array.num[5] = "4列印到五了";
array.num[6] = "43還有兩個2";
array.num[7] = "75762";
array.num[9] = "400-0";
//
array.xs();
}
}

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

F. 如何修改 Java中數組元素的屬性

java里數組也是對象，需要new。你這里缺了句
if( group != null ) result = new int[ group.length ];

G. java中數組的length屬性

數組的length是屬性不是方法。
「int a={1,2,3}」你這樣定義有誤，應該是int [] a={1,2,3},這樣吧
a.length()你這樣寫會出現編譯錯誤！

H. 關於java自定義類的數組屬性問題，給點建議吧~

Student[] stuArr=new Student[2];這句話是定義一個對象類型的數組，比如有兩個學生，一個張三，一個是李四，兩個人有不同的名字和行為，stuArr[0]和stuArr[1]分別代表兩個不同的對象；stuArr[i]=stu; 對於這句話，對象類型數組當然得賦值對象了。跟Sting[]數組類型只能賦值String類型一樣。

I. 在Java中數組屬於什麼類型

類.類的實例當然是對象.有個length的屬性,有任何其他語言的數組應該有的操作,可以下標操作.你就當是java的內置的特別數據類型就是了,性能是被加強過.直接繼承自object,不用關心實現的類或介面,沒什麼意義.用反射看到的類名會是"b[,c[["之類的,"b["表示一維的byte數組,"c[["表示的是二維的char數組.
不要去追究,真的沒有意義.