java定義數組賦值

❶ 在java中定義一個數組對象怎麼賦值

new Shuzu(new char[]{'我'});new Shuzu(new char[]{'老'})); ————相當於ss[0].sz[0]={'我'};ss[1].sz[0]={'老'};

就在這里，這里你用了兩次new，也就意味著，你生成了兩個不同的Shuzu類的對象出來，分別的char[]{'我'}和new char[]{'老'}，所以，當你在之後 System.out的時候，讀到ss[0].sz[1]和ss[1].sz[1]時，其實這兩個變數里是沒有值的，

❷ Java定義一個一維數組，並給每個元素賦值為數組下標的值，並顯示

publicstaticvoidmain(String[]args){
/**
*1、Java定義一個一維數組，並給每個元素賦值為數組下標的值，並顯示
*/
int[]arr=newint[10];

for(inti=0;i<arr.length;i++){
arr[i]=i;
System.out.println(i+","+arr[i]);
}
}

publicstaticvoidmain(String[]args){
/**
*2、修改上述程序，將數組的賦值改為從鍵盤上輸入的10個整數
*/
int[]arr=newint[10];
System.out.println("請依次輸入10個整數");
for(inti=0;i<arr.length;i++){
System.out.println("請輸入第"+(i+1)+"個整數：");
Scannerinput=newScanner(System.in);
arr[i]=Integer.parseInt(input.nextLine());
}
for(inti=0;i<arr.length;i++){
System.out.println(i+","+arr[i]);
}
/**
*3、修改上述程序，添加代碼，實現從10個數中找到最大值和最小值，並顯示。
*/
intmax=arr[0];//將數組的第一個元素賦給max
intmin=arr[0];//將數組的第一個元素賦給min
for(inti=1;i<arr.length;i++){
//從數組的第二個元素開始賦值，依次比較
if(arr[i]>max){
//如果arr[i]大於最大值，就將arr[i]賦給最大值
max=arr[i];
}
if(arr[i]<min){
//如果arr[i]小於最小值，就將arr[i]賦給最小值
min=arr[i];
}
}
System.out.println("最大值是:"+max);
System.out.println("最小值是:"+min);

/**
*4、修改上述程序，添加代碼，去掉最大值和最小值，然後計算剩下的數的平均值，並顯示
*/
intsum=0;
for(inti=0;i<arr.length;i++){
sum+=arr[i];
}
sum=sum-max-min;//去掉最大值和最小值的總和
doubleaverage=sum/(arr.length-2);
System.out.println("平均值："+average);
}

❸ java中如何定義數組元素賦值為-1

java中定義數組元素賦值為-1方法：
1、寫一個方法傳入數組長度，在定義數組的時候你用長度定義一個數組。
2、定義一個一維數組，並給每個元素賦值為數組下標的值。

❹ Java自定義類數組的賦值問題

Catt a[]=new Catt[9];
說明你new了9個，這9個的下標是0,1,2。。。。8，
for(i=0;i<10;i++) i是0,1,2，。。。8,9，當i=9的時候，越界了

a[i].set(name,age,color);
此時，你的a[i]是等於null的，因為你沒有做這個 a[i] = new Catt();

❺ java裡面能不能定義數組，然後在不知道數組長度的情況下為數組賦值

可以，但是有可能會報數組下標越界的錯誤。建議先判斷一下長度，再賦值。
還有就是，為什麼不用ArrayList呢。用add添加，就不會有越界危險了。如果你需要數組的話，toArray()轉變成數組就可以了。

❻ 用java基礎編寫程序，創建一個數組並賦值

代碼：

publicclassArrayTest{

//聲明數組
long[]ii={8,4,2,1,23,344,12};

//判斷
publicvoidjudge(longlon){

for(inti=0;i<ii.length;i++){
if(lon==ii[i]){
System.out.println("猜對了");
return;
}
}
System.out.println("Sorry!");
}

//測試
publicstaticvoidmain(String[]args){

ArrayTestarraytest=newArrayTest();

//手動輸入整數
Scannerscanner=newScanner(System.in);
System.out.println("請輸入一個整數：");
longl=scanner.nextLong();

arraytest.judge(l);
}
}

運行結果：

❼ Java給數組中的數組賦值

packagecom.oceanlive.demo;


publicclassTest{
publicstaticvoidmain(String[]args){
Object[]monitorsys=newObject[4];//定義最大的數組容器
Object[]situation=newObject[2];//定義第一個元素
Object[]sms=newObject[2];//定義第二個元素
Object[]rule=newObject[2];//定義第三個元素
Object[]alertsdb=newObject[2];//定義第四個元素
situation[0]=1;
monitorsys[0]=situation;//賦值操作
monitorsys[1]=sms;
monitorsys[2]=rule;
monitorsys[3]=alertsdb;
//列印的就是第一個元素的數組的地址值(需要強制轉換成Object對象數組，才能從輸出)
System.out.println(((Object[])monitorsys[0])[0]);
}
}

❽ java 數組賦值

int[] b;int[] a ={1,2,3,4};b=a;

答：可以這樣對數組進行賦值。
但是這種方式對數組進行賦值, 實際上是一種淺層復制.
也就是說，b實際上就是a，它們的內存地址值都是一樣的， 當a發生改變，那麼b也會跟著改變 。
為了真正意義上實現賦值，那麼我們應該對數組進行深層復制。
深層復制後，無論a怎麼改變，都不會影響到b。
具體代碼如下

package core.com;import java.util.Arrays;public class DemoCopy { public static void main(String[] args) { //---------淺層復制-------- int[] a; int[] b = {1,2,3,4}; a=b;//淺層復制. 當b改變的時候,a會跟著改變 System.out.println(Arrays.toString(a));//輸出數組a,[1,2,3,4] b[0] = 5;//改變數組b , 數組a也會跟著改變 System.out.println(Arrays.toString(a));//輸出數組a,[5,2,3,4] System.out.println(a==b);//輸出true a就是b //-----------分割線-------- //深層復制方法一: String[] c ; String[] d = {"a","b","c"}; c = new String[d.length]; // 需要初始化數組長度 for (int i = 0; i < d.length; i++) {//循環復制, c[i] = d[i]; } d[0]="y";//改變數組d, 不會影響c System.out.println(Arrays.toString(c));// System.out.println(c==d); //-------------分割線--------- //深層復制方法二: int[] ary1; int[] ary2 = {8,8,8}; ary1 = new int[ary2.length]; System.array(ary2, 0, ary1, 0, ary2.length);//調用函數進行深層復制 ary2[0]=6;//改變數組ary2,並不會影響ary1 System.out.println(Arrays.toString(ary1)); System.out.println(ary1==ary2); }}

控制台輸出

[1, 2, 3, 4][5, 2, 3, 4]true[a, b, c]false[8, 8, 8]false

❾ java 給數組賦值

還是用例子來說話吧：

比如
A a[];//聲明一個數組引用，它指向的數組的元素必須是A型或者A的子類型。
a=new A[10];//創建一個A類型數組，並且讓引用a指向這個數組。
A=new B[100];//創建一個B類型數組，並且讓引用a指向這個數組，這個時候B必須是A的子類，否則編譯不通過。
從上面看到，長度是在數組被創建時才指定的。數據引用本身只知道自己指向的是什麼類型的數組。

實際上，java的數組和對象有著許多相似的地方，完全可以把數組當作對象來看。長度length不過是數組的一個屬性，不同的數組對象此屬性可相同也可以不同。
對象的引用之間，只要類型相同，就可以相互賦值，數組也是這樣的。

2樓的真是膚淺，如果數組沒用的話，java還保留它幹嘛。在讀取文件時還不是要經常用到數組來緩沖嗎？

❿ java怎樣給數組賦值

Object[] array = new Object[ int size ];/Object array[] = new Object[ int size ];size 是數組大小
eg: String[] str = new String[ 10 ];
str[ 0 ] = "1"; str[ 1 ] = "1";

Object[] array = {obj1,obj2,==};/Object array[] = {obj1,obj2,==};

Object[] array = new Object[]{obj1,obj2,==};/Object array[] = new Object[]{obj1,obj2,==};

遍歷：
for(int i = 0;i < array.length;i++){
System.out.println( array[ i ] );
}

或者
for(Object obj : array){
System.out.println( obj );
}