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 );
}