文档章节

Java编程思想: 数组

fzyz_sb
 fzyz_sb
发布于 2016/07/30 17:03
字数 1265
阅读 52
收藏 1

数组的特殊性

数组区别于类容器在于: 效率,类型和保存基本类型的能力.

效率: 数组是线性序列,存储空间大小被固定, 则存储读取效率很高.

类型和保存类型的能力: 数组存储具体的类型, 则它在编译期间就会进行检查类型是否正确.

数组是第一级对象

无论使用哪种类型的数组, 数组标识符其实只是一个引用, 指向在堆中创建的一个真实对象, 这个数组对象用以保存指向其他对象的引用.

以下是数组的一些基本操作:

import java.util.*;

class BerylliumSphere {
  private static long counter;
  private final long id = counter++;
  public String toString() { return "Sphere " + id; }
}
public class ArrayOptions {
  public static void print(Object o) {
    System.out.println(o);
  }
  public static void main(String[] args) {
    BerylliumSphere[] a;
    BerylliumSphere[] b = new BerylliumSphere[5];
    print("b: " + Arrays.toString(b));

    BerylliumSphere[] c = new BerylliumSphere[4];
    for (int i = 0; i < c.length; i++) {
      if (c[i] == null) {
        c[i] = new BerylliumSphere();
      }
    }
    BerylliumSphere[] d = {
      new BerylliumSphere(),
        new BerylliumSphere(),
        new BerylliumSphere()
    };
    a = new BerylliumSphere[] {
      new BerylliumSphere(), new BerylliumSphere()
    };

    print("a.length = " + a.length);
    print("b.length = " + b.length);
    print("c.length = " + c.length);
    print("d.length = " + d.length);
    a = d;
    print("a.length = " + a.length);


    int[] e;
    int[] f = new int[5];
    print("f: " + Arrays.toString(f));
    int[] g = new int[4];
    for (int i = 0; i < g.length; i++) {
      g[i] = i * i;
    }
    int[] h = {11, 47, 93};

    print("f.length: " + f.length);
    print("g.length: " + g.length);
    print("h.length: " + h.length);
    e = h;
    print("e.length: " + e.length);
    e = new int[] {1, 2};
    print("e.length: " + e.length);
  }
}

我们可以返回一个数组, 即将数组当做一个对象即可. 对于C/C++来说, 是无法做到的, 它们只能返回一个指针.

针对多维数组来说, 我们需要Arrays.deepToString()来进行显示:

import java.util.*;

public class ThreeDWithNew {
  public static void main(String[] args) {
    int[][][] a = new int[2][2][4];
    // [[[0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0]]]
    System.out.println(Arrays.deepToString(a));
    // [[[I@628b4796, [[I@2608fb65]
    System.out.println(Arrays.toString(a));
  }
}

 

数组与泛型

我们无法实例化具有参数化类型的数组:

Peel<Banana>[] peel = new Peel<>[10];

这里, 由于擦除的存在, Banana会擦除为Object类型. 但我们可以对Peel进行泛型处理:

import java.util.Arrays;

public class Test {
  public static <T> T[] f(T[] arg) {
    return arg;
  }
  public static void main(String[] args) {
    Integer[] ints = {1, 2, 3};
    Integer[] ints2 = Test.<Integer>f(ints);
    System.out.println(Arrays.toString(ints2));
  }
}

 

创建测试数据

1. 使用Arrays.fill()

import java.util.*;

public class Test {
  public static void main(String[] args) {
    int[] ints = new int[10];
    Arrays.fill(ints, 1);
    // [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
    System.out.println(Arrays.toString(ints));
  }
}

2. 将数据生成器和数组结合起来

import java.util.*;

interface Generator<T> {
  T next();
}
class CountingGenerator {
  public static class Boolean implements Generator<java.lang.Boolean> {
    private boolean value = false;
    public java.lang.Boolean next() {
      value = !value;
      return value;
    }
  }

  public static class Byte implements Generator<java.lang.Byte> {
    private byte value = 0;
    public java.lang.Byte next() {
      return value++;
    }
  }

  static char[] chars = ("abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();
  public static class Charater implements Generator<java.lang.Character> {
    int index = -1;
    public java.lang.Character next() {
      index = (index + 1) % chars.length;
      return chars[index];
    }
  }

  public static class String implements Generator<java.lang.String> {
    private int length = 7;
    Generator<java.lang.Character> cg = new Charater();
    public String() {}
    public java.lang.String next() {
      char[] buf = new char[length];
      for (int i = 0; i < length; i++) {
        buf[i] = cg.next();
      }
      return new java.lang.String(buf);
    }
  }
  public static class Short implements Generator<java.lang.Short> {
    private short value = 0;
    public java.lang.Short next() {
      return value++;
    }
  }
  public static class Integer implements Generator<java.lang.Integer> {
    private int value = 0;
    public java.lang.Integer next() {
      return value++;
    }
  }
  public static class Long implements Generator<java.lang.Long> {
    private long value = 0;
    public java.lang.Long next() {
      return value++;
    }
  }
  public static class Float implements Generator<java.lang.Float> {
    private float value = 0;
    public java.lang.Float next() {
      return value++;
    }
  }
  public static class Double implements Generator<java.lang.Double> {
    private double value = 0;
    public java.lang.Double next() {
      return value++;
    }
  }
}
public class GeneratorsTest {
  public static int size = 10;
  public static void test(Class<?> surroundingClass) {
    for (Class<?> type: surroundingClass.getClasses()) {
      System.out.print(type.getSimpleName() + ": ");
      try {
        Generator<?> g = (Generator<?>)type.newInstance();
        for (int i = 0; i < size; i++) {
          System.out.print(g.next() + " ");
        }
        System.out.println();
      } catch(Exception e) {
        throw new RuntimeException(e);
      }
    }
  }
  public static void main(String[] args) {
    test(CountingGenerator.class);
  }
}

3. 从Generator中创建数组

使用任意的Generator来产生Object子类型的数组:

import java.util.*;

class CollectionData<T> extends ArrayList<T> {
  public CollectionData(Generator<T> gen, int quantity) {
    for (int i = 0; i < quantity; i++) {
      add(gen.next());
    }
  }
  public static <T> CollectionData<T> list(Generator<T> gen, int quantity) {
    return new CollectionData<>(gen, quantity);
  }
}

class Generated {
  public static <T> T[] array(T[] a, Generator<T> gen) {
    return new CollectionData<T>(gen, a.length).toArray(a);
  }
  @SuppressWarnings("unchecked")
  public static <T> T[] array(Class<T> type, Generator<T> gen, int size) {
    T[] a = (T[])java.lang.reflect.Array.newInstance(type, size);
    return new CollectionData<T>(gen, size).toArray(a);
  }
}
public class TestGenerated {
  public static void main(String[] args) {
    Integer[] a = {9, 8, 7, 6};
    // [9, 8, 7, 6]
    System.out.println(Arrays.toString(a));
    a = Generated.array(a, new CountingGenerator.Integer());
    // [0, 1, 2, 3]
    System.out.println(Arrays.toString(a));

    Integer[] b = Generated.array(Integer.class, new CountingGenerator.Integer(), 15);
    // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
    System.out.println(Arrays.toString(b));
  }
}

 

Arrays实用功能

1. 复制数组

使用System.arraycopy来进行数组的复制.

import java.util.*;

public class CopyingArrays {
  public static void print(Object o) {
    System.out.println(o);
  }
  public static void main(String[] args) {
    int[] i = new int[7];
    int[] j = new int[10];
    Arrays.fill(i, 47);
    Arrays.fill(j, 99);
    print("i = " + Arrays.toString(i));
    print("j = " + Arrays.toString(j));
    System.arraycopy(i, 0, j, 0, i.length);
    print("j = " + Arrays.toString(j));

    int[] k = new int[5];
    Arrays.fill(k, 10);
    System.arraycopy(i, 0, k, 0, k.length);
    Arrays.fill(k, 103);
    System.arraycopy(k, 0, i, 0, k.length);
    print("i = " + Arrays.toString(i));

    Integer[] u = new Integer[10];
    Integer[] v = new Integer[5];
    Arrays.fill(u, new Integer(47));
    Arrays.fill(v, new Integer(99));
    print("u = " + Arrays.toString(u));
    print("v = " + Arrays.toString(v));
    System.arraycopy(v, 0, u, u.length / 2, v.length);
    print("u = " + Arrays.toString(u));
  }
}

2. 数组的比较

使用equals来比较.

import java.util.*;

public class Test {
  public static void main(String[] args) {
    int[] a = new int[10];
    int[] b = new int[10];
    int[] c = new int[5];
    System.out.println(Arrays.equals(a, b));
    System.out.println(Arrays.equals(a, c));
  }
}

3. 数组元素的比较

实现Comparable接口即可.

import java.util.*;

class CompType implements Comparable<CompType> {
  public int i;
  CompType(int i) {
    this.i = i;
  }
  public int compareTo(CompType rv) {
    return (i < rv.i ? -1 : (i == rv.i ? 0: 1));
  }
}

public class Test {
  public static void main(String[] args) {
    CompType[] a = {
      new CompType(2),
      new CompType(4),
      new CompType(3),
      new CompType(1),
      new CompType(5)
    };
    Arrays.sort(a);
    for (int i = 0; i < a.length; i++) {
      System.out.print(a[i].i + " ");
    }
  }
}

 

© 著作权归作者所有

fzyz_sb
粉丝 411
博文 209
码字总数 447144
作品 0
武汉
程序员
私信 提问
那些年,关于 Java 的那些事儿

版权声明:Follow your heart and intuition. https://blog.csdn.net/qq_35246620/article/details/78695893 温馨提示:本系列博文(含示例代码)已经同步到 GitHub,地址为「java-skills」,...

维C果糖
2017/12/02
0
0
用JS角度看Java,关于数组

很长时间没来简书了,说不上忙,却也不想写东西,不想学习; 只是最近突发奇想,想用java实现js数组——及用一个List对象去储存各种各样类型的数据。js是弱类型语言,其灵活的语法给开发带来...

扶摇十万里
2018/11/09
0
0
大数据开发培训:0基础学习Java编程语言有哪些知识点?

Java 技术通用、高效、具有平台移植性和安全性,广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网等,学习Java首先要知道学习知识点有哪些。在这就用加米谷大数据培训...

加米谷大数据
2018/07/25
0
0
Scala笔记整理(二):Scala数据结构—数组、map与tuple

[TOC] 数组 定长数组 如果你需要一个长度不变的数组,可以用Scala中的Array。例如: 在JVM中,Scala的Array以Java数组方式实现。示例中的数组在JVM中的类型为java.lang.String[]。Int、Doubl...

xpleaf
2018/04/18
0
0
为什么我会弃Java,选择了Kotlin——专访《Java编程思想》作者 Bruce Eckel

点击上方“CSDN”,选择“置顶公众号” 关键时刻,第一时间送达! 这是前不久我们发布《Kotlin或将取代Java》一文之后,来自网友们的部分声音。 可以看到:作为编程语言界的老大——Java仍然...

csdnnews
2018/05/30
0
0

没有更多内容

加载失败,请刷新页面

加载更多

任务调度-Spring+第三方库Quartz实现分布式任务管理与调度

1. 为什么要用Spring+第三方库Quartz来实现分布式任务管理和调度? 首先管理的目的是通过集群多节点的管理提供容错,调度的目的是保证同一任务只会被完整执行一次;之前分享过的任务调度-单体...

秋日芒草
3分钟前
0
0
Mysql Explain Type

前言 当我们执行sql,一般都会用Explain来查看sql的效率如何。今天在看sql执行效率的时候,忘记了其中Type的意思,现在在此记录一下。 效率 这里的type指的是访问类型,各个效率高低如下: ...

无敌小杰杰
11分钟前
0
0
外部浏览器网页复制公众号无法自动唤起微信并关注怎么办?

现在有很多用户在外部浏览器网页复制公众号时无法自动唤起微信并关注,这是因为第三方浏览器打开微信的接口,微信只给部分合作平台开放了接口权限,任何第三方想调用只能是通过一些技术手段来...

qjniop
15分钟前
0
0
建造者模式

建造者模式(Builder Pattern) 也叫生成器模式,其定义如下: Separate the construction of a complex object from its representation so that the same construction process can create d......

无知的小狼
20分钟前
0
0
距离计算方法

1、欧式距离(欧几里得距离) 欧式距离是最易理解的距离定义,即各坐标点的坐标之差的平方和相加,然后开根号。 二维平面上点 与点 之间的距离公式是: n维空间上点 和点 之间的距离公式是:...

城北徐公美
23分钟前
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部