精华内容
下载资源
问答
  • 可以使用类java.security.Provider中的getName()方法获取提供者的名称。此方法不需要任何参数,并根据需要返回提供者的名称。演示此的程序如下所示-示例importjava.security.*;importjava.util.*;publicclassDemo{...

    可以使用类java.security.Provider中的getName()方法获取提供者的名称。此方法不需要任何参数,并根据需要返回提供者的名称。

    演示此的程序如下所示-

    示例import java.security.*;

    import java.util.*;

    public class Demo {

    public static void main(String[] argv) {

    try {

    KeyPairGenerator kpGenerator = KeyPairGenerator.getInstance("DSA");

    Provider p = kpGenerator.getProvider();

    System.out.println("The Provider is: " + p.getName());

    } catch (NoSuchAlgorithmException e) {

    System.out.println("Error!!! NoSuchAlgorithmException");

    }

    }

    }

    输出结果The Provider is: SUN

    现在让我们了解上面的程序。

    getProvider()方法用于获取键对对象的提供者。然后显示提供者。如果算法名称错误,则会引发异常NoSuchAlgorithmException。演示的代码片段如下-try {

    KeyPairGenerator kpGenerator = KeyPairGenerator.getInstance("DSA");

    Provider p = kpGenerator.getProvider();

    System.out.println("The Provider is: " + p.getName());

    } catch (NoSuchAlgorithmException e) {

    System.out.println("Error!!! NoSuchAlgorithmException");

    }

    展开全文
  • Java 数组

    2021-03-04 04:31:35
    1.定义数组的方式类/基本类型 [] 数组名 = new类/基本类型[长度];例如:node[] a=new node[5];int [] b=new int[6];double []c=new double[6];缺点:长度固定,不够灵活定义的时候就初始化了,类数组的初始值是null...

    1.定义数组的方式

    类/基本类型 [] 数组名 = new 类/基本类型[长度];

    例如:

    node[] a=new node[5];int [] b=new int[6];

    double []c=new double[6];

    缺点:长度固定,不够灵活

    定义的时候就初始化了,类数组的初始值是null,基本类型数组的初始值是0;

    for(int i=0;i

    System.out.println("i="+i+" "+a[i]+" "+b[i]+" "+c[i] );/*输出

    i=0 null 0 0.0

    i=1 null 0 0.0

    i=2 null 0 0.0

    i=3 null 0 0.0

    i=4 null 0 0.0*/

    2.获取长度

    数组名.length;

    a.length;b.length;

    用于遍历,越界访问则异常

    3.内存

    int[] x = null;

    x= new int[3];

    x[0] = 10;

    x[1] = 20;

    x[2] = 30;

    x= null;

    29cc005d8f453c6999708a19611b2176.png

    4.引用

    int[] a=new int[4];

    等号右侧:创建了一个int型数组对象

    等号左侧:变量a称为该对象的引用(Reference)

    称作:变量a指向一个对象

    int[] a=new int[4];int[] b=a;

    a指向一个对象,b指向 和 a指向 相同 的对象,a和b都是该对象的引用,a和b都可以操作目标对象

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

    a=null;//空对象

    此时a不指向任何对象,不能再访问,比如把数组第一个值改为12,a[0]=12会出错,但是b[0]=12不会出错。

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

    System.out.println(a[0]+" "+a[1]+" "+a[2]);

    a=new int[3];

    a[0]=a[1]=a[2]=55;

    System.out.println(a[0]+" "+a[1]+" "+a[2]);/**输出

    1 2 3

    55 55 55*/

    创建一个数组对象obj1,内容为1,2,3,4

    创建另一个数组对象obj2,内容为0,0,0

    obj2内容变为55,55,55

    此时obj1无人引用(失去引用的对象),会被java系统自动回收

    如果想保留obj1,应该a=new int[3];之前加一句int [] b = a;这样可以使b引用a,a另外去引用别的也没关系。

    5.匿名数组

    在栈内存中没有任何引用,只在堆内存开辟空间,存放数据

    System.out.println(new int[]{1,2,3}.length);

    和失去引用的对象一样,用一次就废了,没办法重用,会被java系统自动回收。

    6.用Arrays实现对数组的操作

    导入包:import java.util.Arrays;

    (1)排序

    语法:Arrays.sort(数组名);

    可以使用 sort() 方法实现对数组的排序,只要将数组名放在 sort( ) 方法的括号中,就可以完成对该数组的排序(按升序排列),字符串则以首字母排序

    (2)将数组转换为字符串后捆绑输出

    语法:Arrays.toString(数组名);

    可以使用 toString() 方法将一个数组转换成字符串,该方法按顺序把多个数组元素连接在一起,多个元素之间使用逗号和空格隔开

    importjava.util.Arrays;public classMyTest8 {public static voidmain(String[] args) {

    String[] hobbies= { "sports", "game", "movie"};int [] a= {11,33,44};for(int i=0;i

    System.out.println(hobbies[i]);

    System.out.println(Arrays.toString(hobbies) );

    System.out.println(Arrays.toString(a) );

    }

    }

    输出:

    sports

    game

    movie

    [sports, game, movie]

    [11, 33, 44]

    (3)复制数组

    语法: 数据类型 [] 新的数组名 = Arrays.copyOf(需要复制的数组名,需要复制的长度);

    public classMyTest8 {public static voidmain(String[] args) {int [] a = {11,33,44,20,53,87};//初始化长度为6的数组

    int [] c1 = Arrays.copyOf(a,2);//复制前2个长度的数组

    int [] c2 = Arrays.copyOf(a,4);//复制前4个长度的数组

    int [] c3 = Arrays.copyOf(a,a.length);//完全复制

    System.out.println("a数组的长度"+a.length);

    System.out.println("c1数组的长度"+c1.length);

    System.out.println("c2数组的长度"+c2.length);

    System.out.println("c3数组的长度"+c3.length);for(int i=0;i

    System.out.print(a[i]+" ");

    System.out.println();for(int i=0;i

    System.out.print(c1[i]+" ");

    System.out.println();for(int i=0;i

    System.out.print(c2[i]+" ");

    System.out.println();for(int i=0;i

    System.out.print(c3[i]+" ");

    System.out.println();

    }

    }

    输出:

    a数组的长度6

    c1数组的长度2

    c2数组的长度4

    c3数组的长度6

    11 33 44 20 53 87

    11 33

    11 33 44 20

    11 33 44 20 53 87

    7.作为参数传入方法

    public classMyTest8 {public static voidmain(String[] args) {int [] a= {11,33,44};

    MyTest8 test=newMyTest8();

    test.print(a);

    System.out.println("2 "+a[0]+" "+a[1]+" "+a[2]);

    test.print2(a);

    System.out.println("4 "+a[0]+" "+a[1]+" "+a[2]);

    }public void print(int[]c )

    {

    System.out.println("1 "+c[0]+" "+c[1]+" "+c[2]);

    c[0]=10;c[1]=20;c[2]=30;

    }public void print2(inta[])//形参名可以相同,并且int [] a和int a[]效果一样

    {

    System.out.println("3 "+a[0]+" "+a[1]+" "+a[2]);

    a[0]=a[1]=a[2]=1;

    }

    }

    输出:

    1 11 33 44

    2 10 20 30

    3 10 20 30

    4 1 1 1

    理解:方法里的形参,相当于创建新的引用来 共同引用a数组,可以对a数组进行操作,进行的操作直接对堆中的数据进行修改。

    8.类数组

    类 [] 数组名 = new 类[长度];

    packagemy_acm;importjava.util.Arrays;public classMyTest8 {public static voidmain(String[] args) {

    Student[] stu= new Student[3];for(int i=0;i

    System.out.println(stu[i]);

    stu[0]=new Student(1);

    stu[1]=new Student(2,"守林鸟");

    stu[2]=new Student(3,"霸王别鸡",21);

    System.out.println(stu.length);for(int i=0;i

    System.out.println(stu[i]);for(int i=0;i

    System.out.println(stu[i].toString());

    stu[0].say();

    }

    }classStudent{private intid;privateString name;private intage;public Student(intid) {this.id=id;

    }public Student(intid,String name) {this(id);//调用一个参数的构造方法

    this.name=name;

    }public Student(int id,String name,intage) {this(id,name);//调用2个参数的构造方法

    this.age=age;

    }public intgetId() {return this.id;

    }publicString getName() {returnname;

    }public intgetAge() {returnage;

    }public voidsetName(String name) {this.name =name;

    }public void setAge(intage) {this.age =age;

    }public void setId(intid) {this.id =id;

    }public voidsay() {

    System.out.println("hello");

    }public String toString() {//重写toString方法

    return "id="+this.id+" name="+this.name+" age="+this.age;

    }

    }

    输出:

    null

    null

    null

    3

    id=1 name=null age=0

    id=2 name=守林鸟 age=0

    id=3 name=霸王别鸡 age=21

    id=1 name=null age=0

    id=2 name=守林鸟 age=0

    id=3 name=霸王别鸡 age=21

    hello

    推测:创建对象的引用数组stu,一开始引用都是null,直到new之后堆中才开辟内存空间,分别创建3个对象,再通过stu引用,对于字符串,初始值是null,基本类型初始值则是0,直接输出对象则默认调用toString()方法,这个方法默认返回该对象实现类的类名 + @ +hashCode值。一般都被重写,江湖上的不成文规定是返回属性+值。

    展开全文
  • 数组的本质

    2021-03-08 00:15:04
    Java中的数组是对象吗要判断数组是不是对象,那么首先明确什么是对象,也就是对象的定义。在较高的层面上,对象是根据某个类创建出来的一个实例,表示某类事物中一个具体的个体。对象具有各种属性,并且具有一些特定...

    Java中的数组是对象吗

    要判断数组是不是对象,那么首先明确什么是对象,也就是对象的定义。在较高的层面上,对象是根据某个类创建出来的一个实例,表示某类事物中一个具体的个体。对象具有各种属性,并且具有一些特定的行为。而在较低的层面上,站在计算机的角度,对象就是内存中的一个内存块,在这个内存块封装了一些数据,也就是类中定义的各个属性,所以,对象是用来封装数据的。以下为一个Person对象在内存中的表示:

    a1395ca02133a251498c45737982b173.png

    那么在Java中,数组满足以上的条件吗?在较高的层面上,数组不是某类事物中的一个具体的个体,而是多个个体的集合。那么它应该不是对象。而在计算机的角度,数组也是一个内存块,也封装了一些数据,这样的话也可以称之为对象。以下是一个数组在内存中的表示:

    7e174934e86f1d2e5a89aee8574ea4af.png

    这样的话, 数组既可以是对象,也可以不是对象。至于到底是不是把数组当做对象,全凭Java的设计者决定。数组到底是不是对象, 通过代码验证:

    int[] a=new int[4];

    //数组可以访问属性

    int len = a.length;

    //数组可以调用方法

    a.clone();

    a.toString();

    Java中的数组具有其他对象的一些特点:封装了一些数据,可以访问属性,也可以调用方法,所以Java中的数组是对象。再来对比C++ 中的数组:

    int main(){

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

    int* pa = a;

    //无法访问属性,也不能调用方法。

    return 0;

    }

    C++ 中的数组虽然封装了数据,的那还是数组名只是一个指针,指向数组中的首个元素,既没有属性也没有方法可以调用,所以C++ 中的数组不是对象,只是一个数据的集合。

    Java中数组的类型

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

    System.out.println(arr1.getClass().getName());

    //打印出的数组类的名字为[I

    String[] arr2 = new String[2];

    System.out.println(arr2.getClass().getName());

    //打印出的数组类的名字为 [Ljava.lang.String;

    String[][] arr3 = new String[2][3];

    System.out.println(arr3.getClass().getName());

    //打印出的数组类的名字为 [[Ljava.lang.String;

    数组也是有类型的。只是这个类型显得比较奇怪。你可以说arr1的类型是int[],这也无可厚非。但是我们没有自己创建这个类,也没有在Java的标准库中找到这个类。也就是说不管是我们自己的代码,还是在JDK中,都没有如下定义:

    public class int[] {

    // ...

    // ...

    // ...

    }

    数组类型的创建

    在《Java语言规范》中,数组具有以下几点特点:

    在Java编程语言中,数组是动态创建的对象,可以被赋值给Object类型的变量。Object类的所有方法都可以在数组上调用。

    数组对象包含大量的变量。

    数组的所有元素都具有相同的类型,称为数组的元素类型。如果数组的元素类型为T,那么数组自身的类型就写作T[ ]。

    int[] arr1 = {1,2};//隐式地创建一个新的数组对象

    int[] arr2 = new int[2];//显式地创建一个数组对象

    Object o = arr2;//数组对象可以赋值给Object类型的变量

    o = arr1;

    通过上面的代码片段,再联系“数组是动态创建的对象”这句话,我们可以猜测:数组的类型很可能是运行时通过反射动态创建的,并且其类型是Object的子类。

    数组类型的成员

    public final 属性 length,它包含了数组的元素数量。length可以是正数或0。

    public 方法 clone,它覆盖了Object类中的同名的方法,并且不会抛出任何受检异常。

    多维数组的克隆是浅复制,即它只创建单个新数组,子数组是共享的。

    所有从Object类继承而来的成员。

    下面的例子说明多维数组克隆后共享子数组:

    int ia[][] = { { 1, 2 }, null };

    int ja[][] = ia.clone();

    System.out.print((ia == ja) + " ");

    System.out.println(ia[0] == ja[0] && ia[1] == ja[1]);

    数组的Class对象

    每个数组都与一个Class对象关联,并与其它具有相同元素类型的数组共享该对象。尽管数组类型不是类,但是每一个数组的Class对象起到的作用看起来都像是。

    class A {

    }

    class B extends A implements Comparable {

    @Override

    public int compareTo(B o) {

    return 0;

    }

    }

    public class Test {

    public static void main(String[] args) {

    B[] bArr1 = new B[2];

    B b = new B();

    B[] bArr2 = new B[2];

    //测试数组的Class对象是共享的

    System.out.println(bArr1 == bArr2);

    //输出:false

    System.out.println(bArr1.getClass() == bArr2.getClass());

    //输出:true

    //测试数组bArr1和b的Class对象是否一样

    System.out.println(bArr1.getClass() + " | " + b.getClass());

    //输出:class [Lcom.ninety.B; | class com.ninety.B

    //测试数组bArr2和b的父类是否一样

    System.out.println(bArr1.getClass().getSuperclass() + " | " + b.getClass().getSuperclass());

    //输出:class java.lang.Object | class com.ninety.A

    //测试数组bArr1和b实现的接口分别是什么

    for(Class>c : bArr1.getClass().getInterfaces()){

    System.out.println("Superinterfaces: " + c);

    }

    //输出:

    //Superinterfaces: interface java.lang.Cloneable

    //Superinterfaces: interface java.io.Serializable

    for(Class>c : b.getClass().getInterfaces()){

    System.out.println("Superinterfaces: " + c);

    }

    //输出:Superinterfaces: interface java.lang.Comparable

    }

    }

    其中,字符串“[Lcom.ninety.B”是“元素类型为com.ninety.B的数组”的Class对象的运行时类型签名。

    根据上面的输出结果,可得出以下总结:

    数组的Class对象是共享的。

    虽然每个数组都与一个 Class 对象关联,但数组的Class对象并不等于数组元素的Class对象。

    从上面这个输出可以看出:class [Lcom.ninety.B; | class com.ninety.B

    数组的类型是Object类的子类,并且数组的类型和数组元素的类型不一样。

    如上面的输出中, B[] 的父类是Object,而B的父类是A。B[]类型实现的是Cloneable 和 Serializable 接口,而B类实现的是Comparable接口。

    Java中数组的继承关系

    上面已经验证了,数组是对象,也就是说可以以操作对象的方式来操作数组。并且数组在虚拟机中有它特别的类型。既然是对象,遵循Java语言中的规则---顶层父类是Object。这就说明数组对象可以向上直接转型到Object,也可以向下强制类型转换,也可以使用instanceof关键字做类型判定。这一切都和普通对象一样。

    int[] arr1=new int[2];

    //将arr1向上转型为Object

    Object o=arr1;

    int[] arr2=(int[])o;

    //使用instanceof关键字判定

    if(o instanceof int[]){

    System.out.println("o的真实类型是int[]");

    }

    由上文的验证可以得知数组类型的顶层父类一定是Object,那么下面的代码很容易让我们疑惑:

    String[] s = new String[5];

    //可以用Object[]的引用来接收String[]的对象

    Object[] obja = s;

    Object[]类型的引用可以指向String[]类型的数组对象?数组类型的顶层父类一定是Object,那么上面代码中s的直接父类是谁呢?难道说String[]继承自Object[],而Object[]又继承自Object? 让我们通过反射的方式来验证这个问题:

    System.out.println(s.getClass().getSuperclass().getName());

    //打印结果为java.lang.Object,说明String[] 的直接父类是 Object而不是Object[]

    由代码可知,String[]的直接父类就是Object而不是Object[]。可是Object[]的引用明明可以指向String[]类型的对象。除非String[]不可能即继承Object,又继承Object[]。这样的话就违背了Java单继承的原则。那么只能这样解释:数组类直接继承了Object,关于Object[]类型的引用能够指向String[]类型的对象,这种情况只能是Java语法之中的一个特例,并不是严格意义上的继承。也就是说,String[]不继承自Object[],但是我可以允许你向上转型到Object[],这种特性是赋予你的一项特权。

    其实这种关系可以这样表述:如果有两个类A和B,如果B继承(extends)了A,那么A[]类型的引用就可以指向B[]类型的对象。如下代码所示:

    class A {

    }

    class B extends A {

    }

    public class Test {

    public static void main(String[] args) {

    B[] bArr = new B[2];

    A[] aArr = bArr;

    System.out.println(bArr.getClass().getSuperclass().getName());

    //class java.lang.Object,说明B[]的直接父类是Object

    }

    }

    上面的结论可以扩展到二维数组和多维数组:

    B[][] bArr = new B[2][4];

    A[][] aArr = bArr;

    上面的代码可以这样理解:

    将A[][]数组看成是一维数组,这是个数组中的元素为A[],将B[][]数组看成是一维数组,这是个数组中的元素为B[],因为A[]类型的引用可以指向B[]类型的对象,所以,根据上面的结论,A[][]的引用可以指向B[][]类型的对象。

    数组的这种用法不能作用于基本类型数据:

    int[] aArr = new int[4];

    //错误的,不能通过编译

    //Object[] oArr = aArr;

    这是错误的, 因为int不是引用类型,Object不是int的父类,在这里自动装箱不起作用。但是这种方式是可以的:

    Object[] objss = {"aaa", 1, 2.5};

    这种情况下自动装箱可以工作,也就是说,Object数组中可以存放任何值,包括基本数据类型。这种特性主要是用于方法中参数的传递。如果不传递数组,而是依次传递各个值,会使方法参数列表变得冗长。如果使用具体的数组类型,如String[],那么就限定了类型,失去了灵活性。所以传递数组类型是一种比较好的方式。但是如果没有上面的数组特性(如果有两个类A和B,如果B继承(extends)了A,那么A[]类型的引用就可以指向B[]类型的对象),那么数组类型就只能通过Object类型接收,这样就无法在方法内部访问或遍历数组中的各个元素。如下代码:

    private static void test() {

    String[] a = new String[3];

    doArray(a);

    }

    private static void doArray(Object[] objs){

    }

    private static void doArray1(Object obj){

    //不能用Object接收数组,因为这样无法对数组的元素进行访问

    // obj[1] //错误

    //如果在方法内部对obj转型到数组,存在类型转换异常的风险

    // Object[] objs = (Object[]) obj;

    }

    private static void doArray2(String[] strs){

    //如果适用特定类型的数组,就限制了类型,失去灵活性和通用性

    }

    private static void doArray3(String name, int age, String id, float account){

    //如果不适用数组而是依次传递参数,会使参数列表变得冗长,难以阅读

    }

    展开全文
  • 1.二维数组:二维数组就是存储一维数组(内存地址/引用)的数组 2.二维数组的初始化1) int intA[][]={{1,2},{2,3},{3,4,5}};2) int [][] intB=new int[3][5];3) int []intC []=new int[3][];intC[0]=new int[2];intC[1...

    1.二维数组:二维数组就是存储一维数组(内存地址/引用)的数组

    dbdd3487b4cabd12bf1e5fea5102d1c6.png

    2.二维数组的初始化

    1) int intA[][]={{1,2},{2,3},{3,4,5}};

    2) int [][] intB=new int[3][5];

    3) int []intC []=new int[3][];

    intC[0]=new int[2];

    intC[1]=new int[3];

    intC[2]=new int[5];

    1 public classTestArray2 {2 public static voidmain(String[] args) {3 //二维数组不是规则的矩阵

    4 int [] intA[] ={{1,2},{2,3,4},{3,4,5,6}};5 System.out.println(intA);//[[I@5e265ba4 两个[[表示是二维的 I表示数组是int型 @5e265ba4是内存地址6

    7 //声明一一个二维数组,用于存储3个一维数组,每一个一维数据存多少个数组,不知道 ,null

    8 int [][]intB=new int[3][];9 intB[0]=new int[3]; //3

    10 intB[1]=new int[]{1,2,3,4}; //3

    11 intB[2]=new int[2]; //2

    12 System.out.println(intB[1]);//[I@156643d4

    13 System.out.println(intB[1][1]);//214

    15 //声明一个二维数组,同时创建出一维数组,每个一维数组的长度均相同16 //存储三个一维数组,每个一维数组的长度为4

    17 int []intC[]=new int[3][4];18 System.out.println(intC);19

    20 }21 }

    3.二维数组的遍历

    1) 普通 for 循环

    2) 加强 for 循环

    3) 普通 for 循环+加强 for 循环

    d4eefefc20946bba6057708c173a83cfd89.jpg

    f489c1e7ae8a492fe41963e6e344be5d45d.jpg

    public classTestArray3 {public static voidmain(String[] args) {//二维数组

    int [] intA[] ={{1,2},{2,3,4},{3,4,5,6}};//(1)普通for循环

    for(int i=0;i

    for(int j=0;j

    System.out.print(intA[i][j]+"\t");

    }

    System.out.println();

    }//(2)加强for循环

    System.out.println("\n=========================");for(int[] arr:intA){ //int[]二维数组中元素的类型, arr迭代变量, intA二维组的名称

    for(int i:arr){ //int,一维数组中元素的类型,i,迭代变量,arr,一维数组的名称

    System.out.print(i+"\t");

    }

    System.out.println();

    }//(3)普通与加强for循环的混搭

    System.out.println("\n-------------------------");for(int [] arr:intA){//加强for

    for(int i=0;i

    System.out.print(arr[i]+"\t");

    }

    System.out.println();

    }

    System.out.println("\n--------------------------");for(int i=0;i

    System.out.print(j+"\t");

    }

    System.out.println();

    }

    }

    }

    View Code

    4.对象数组存储表格数据

    张三   19   男

    李四   20   女

    王五   28   男

    数组存基本数据类型,也可以存引用数据类型

    对象数组:使用数组存储对象(自定义对象)

    83165d3206cd11b2be0b0a1722d0f9b45ce.jpg

    19f5dff89ca24ca837d00658abdf0f6d431.jpg

    public classPerson {private String name;//姓名

    private int age;//年龄

    private String gender;//性别//重写toString以打印想要的输出 否则只会打印对象的内存地址

    @OverridepublicString toString() {//TODO Auto-generated method stub

    return name+"\t"+age+"\t"+gender;//}public Person(String name, intage, String gender) {super();this.name =name;this.age =age;this.gender =gender;

    }publicPerson() {super();

    }publicString getName() {returnname;

    }public voidsetName(String name) {this.name =name;

    }public intgetAge() {returnage;

    }public void setAge(intage) {this.age =age;

    }publicString getGender() {returngender;

    }public voidsetGender(String gender) {this.gender =gender;

    }

    View Code

    1 public classTestArray {2 public static voidmain(String[] args) {3 //创建一个Person类型的数组,用于存储3个Person类型的对象

    4 Person [] pers=new Person[3];5 //创建Person类型的对象

    6 Person p1=new Person("张三", 19, "男");7 //将p1对象存储到Person类型的数组中

    8 pers[0]=p1;9

    10 pers[1]=new Person("李四", 20, "女");11 pers[2]=new Person("王五",28,"男");12

    13 for(int i=0;i

    17 }18 }

    f8316a9061c6513a3fd7eef9f472976e.png

    5.数组拷贝

    地址的拷贝

    int[]array={11,22,33,44};

    int[] arrayB=new int[5];

    arrayB=array   //两个数组指向同一内存

    值的拷贝

    int[]array={11,22,33,44};

    int[] arrayB=new int[5];

    arrayB[0]=array[0];

    System 类中的 arraycopy(…)方法:快速,数组大时用次方法。

    1 public classTestArrayCopy3 {2 public static voidmain(String[] args) {3 int [] arrA={11,22,33,44};//源数组

    4 int [] arrB=new int[5];//目标数组

    5

    6 System.out.println("数组拷贝之前");7 for(intnum:arrB){8 System.out.print(num+"\t");9 }10 //0 0 0 0 011 //拷贝

    12 System.arraycopy(arrA, 0, arrB, 1, 2);13

    14 System.out.println("\n数组拷贝之后");15 for(intnum:arrB){16 System.out.print(num+"\t");17 }18 //0 11 22 0 0

    19 }20 }

    展开全文
  • Java中数组的特性

    2021-02-12 21:14:46
    数组是基本上所有语言都会有的一种数据类型,它表示一组相同类型的数据的集合,具有固定的长度,并且在内存中占据连续的空间。在C,C++等语言中,数组的定义简洁清晰,而在java中确有一些会让人迷惑的特性。本文就...
  • Java 对象数组

    2021-02-12 16:09:44
    数组和集合类同的区别: 数组可以存储同一种类型的基本数据也可以存储同一种类型的对象,但长度是固定的 集合只可以存储不同类型的对象,长度是可变的 集合类的特点:集合只用于存储对象,集合长度是可变的,集合可以...
  • Java数组排序

    千次阅读 2021-02-26 21:24:19
    有的时候需要对数组里的element进行排序。当然可以自己编写合适的排序方法,但既然java包里有自带的Arrays.sort排序方法,在 数组元素比较少的时候为何不用?Sorting an Array 1. 数字排序 int[] intArray = new int...
  • public class demo2 {public static void main(String[] args) {/*** 一维数组使用*///数组最大的缺陷:长度固定//int data[] = {10, 20, 30}; /*开辟了一个长度为3的数组*///int[] arr3 = new int[]{1, 2, 3, 4, 5,...
  • Java - 数组解析

    2021-02-12 13:45:32
    一、什么是数组数组?什么是数组?在我印象中的数组是应该这样的:通过new关键字创建并组装他们,通过使用整形索引值访问它的元素,并且它的尺寸是不可变的!但是这只是数组的最表面的东西!深一点?就是这样:数组...
  • 1. 多态数组 数组的定义类型为父类类型,里面保存的实际元素类型为子类类型 应用实例:现有一个继承结构如下:要求创建 1 个 Person 对象、2 个 Student 对象和 2 个 Teacher 对象, 统一放在数组中,并调用每个...
  • java声明对象数组

    千次阅读 2021-03-15 03:45:06
    java如何对象创建数组并初始化急夜影驱动编程小编今天和大家分享答案/** * 功能:声明一个学生类 * @author qqliweng * 时间:2009-10-22 * 版本:V1.0 */ public class Student { private String name; //学员姓名 ...
  • /*** 对象数组的使用*/package com.test5;import java.io.BufferedReader;import java.io.InputStream;import java.io.InputStreamReader;public class Test2 {public static void main(String[] args) throws ...
  • 《java jdk5.0 学习笔记》良葛格 第五章数组2.如何理解数组的length?http://blog.csdn.net/treeroot/archive/2005/01/22/264001.aspx3.关于java数组的深度思考...
  • 数组数据生成器

    2021-03-15 01:25:23
    packagecom.bsc.algorithm.data.generator;importjava.lang.reflect.Array;.../*** 数组生成器*@authorbsc**/public classArrayGenerator {/*** 随机生成size大小的数组*@paramarrayClass 数组class,例如Integer[]...
  • /*** 根据StringBuilder类的相关源码创建属于自己的数组类* 该类与jdk中的数组的区别在于该类中可以存储任何的对象* jdk中的数组只能存储char* @author 刘涛**/public class MyArrayList {private Object[] value;...
  • /*创建数组时,所有元素初始化为0,如:布尔数组为false 对象数组为null*/ public class array { public static void main(String[] args) { String[] s;//声明数组 var a= new int[100];//创建数组 int[] b={1,5,8...
  • Java 数组一、什么是数组数组?什么是数组?在我印象中的数组是应该这样的:通过new关键字创建并组装他们,通过使用整形索引值访问它的元素,并且它的尺寸是不可变的!但是这只是数组的最表面的东西!深一点?就是...
  • java类怎样定义数组对象数组在c++编程中,怎么定义对象数组的指针?JAVA中怎么初始化对象数组?java中怎么创建对象数组?比如我创建了一个学生类Sclass Student{ } 类... public String getName() { return name; } ...
  • Java 数组对象

    2020-12-23 11:05:01
    数组是一种能够通过位置索引,快速、随机地存取其中元素的集合数据结构。对象类型In the Java programming language, arrays are objects (§4.3.1), are dynamically created, and may be assigned to variables of...
  • Java数组和引用

    2021-03-09 17:22:09
    } } } 我可以通过对考试数组进行排序然后从最大的数据中减去最小数来获得考试范围,但是一旦我这样做,我如何找到具有最大考试范围的学生,并将其返回? 解决方法: 你这样做的方法是循环学生,并有一个变量来保持最大的...
  • java 数组排序 Comparator

    2021-03-24 09:24:33
    //按书名长度排序 Arrays.sort(books, new Comparator() { @Override public int compare(Book o1, Book o2) { // 调整o1和o2的顺序可以调整排序方式(从大到小,或者从小到大) return o1.getName().length() - o2....
  • java 创建自定义数组

    2021-02-12 10:40:35
    1.java创建自定义类数组方法:Student []stu = new Student[3];for(int i = 0; i < 3; i ++){stu[i] = new Student();}2.否则会提示空指针异常package project;import java.io.*;import java.util.Scanner;class...
  • //构建employee数组 staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15); staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1); staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15...
  • 数组介绍:数组是一种数据结构,系统为数组分配的存储空间是连续的、指定长度的且大小固定不变的,用来存储一组大小固定并且类型相同的数据。这些数据可以通过索引进行访问,数组的下标索引是从0开始,其取值范围必需...
  • 数组和集合类同的区别: 数组可以存储同一种类型的基本数据也可以存储同一种类型的对象,但长度是固定的 集合只可以存储不同类型的对象,长度是可变的 集合类的特点:集合只用于存储对象,集合长度是可变的,集合可以...
  • import java.util.ArrayList;//数组遍历删除,添加public class Core2 {private String name;private int num;private String color;public Core2() {}public Core2(String a, int b, String c) {name = a;num ...
  • } private ArrayUtil() ...{ } /** *//** * 注入对象数组产生指定大小对象数组 * * @param clazz * @param maxSize */ private ArrayUtil(Class clazz, int maxSize) ...{ // 转为指定大小对象数组 Object array = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 210,455
精华内容 84,182
关键字:

数组getname