Maison >Java >javaDidacticiel >Introduction à l'utilisation des tableaux JAVA
L'éditeur de cet article vous présentera l'utilisation des tableaux JAVA. Les amis dans le besoin peuvent s'y référer
Il existe trois différences principales entre les tableaux JAVA et les classes de conteneurs : l'efficacité, le type. et la possibilité de sauvegarder les types de base. En JAVA, les tableaux constituent le moyen le plus efficace de stocker et d’accéder de manière aléatoire à une séquence de références d’objets. Un tableau est une séquence linéaire simple, qui rend l’accès aux éléments très rapide. Mais le prix à payer est que la taille de la baie est fixe et ne peut pas être modifiée au cours de sa durée de vie.
Grâce à l'émergence des génériques et des mécanismes d'emballage automatiques, les conteneurs peuvent désormais être utilisés avec des types de base presque aussi facilement que des tableaux. Les tableaux et les conteneurs peuvent vous empêcher d'en abuser dans une certaine mesure. S'ils dépassent les limites, vous obtiendrez une RuntimeException. Le seul avantage restant des tableaux est l'efficacité. Cependant, si vous souhaitez résoudre des problèmes plus généraux, les tableaux peuvent être trop restrictifs, donc dans ce cas, la plupart des gens choisiront toujours des conteneurs.
Par conséquent, si vous utilisez des versions JAVA récentes, les conteneurs doivent être préférés aux tableaux. Les programmes ne doivent être refactorisés vers des tableaux que si les performances s'avèrent être un problème et que le passage aux tableaux améliore les performances.
[Initialisation]
JAVA a des réglementations très strictes sur l'initialisation des tableaux, ce qui peut efficacement empêcher l'abus des tableaux. S'il y a une erreur d'initialisation, vous obtiendrez directement CompileException au lieu de RuntimeException. Rien ne peut être fait avec cette référence de tableau tant que le tableau n'est pas correctement initialisé.
Les définitions de tableau incluent int[] array et int array[]. Généralement, le premier style est utilisé pour séparer le type du nom de la variable.
Il existe deux façons d'initialiser des tableaux : l'initialisation statique et l'initialisation dynamique. La longueur doit être spécifiée lors de l'initialisation. La longueur de la première dimension du tableau multidimensionnel doit être indiquée, et elle doit être définie des dimensions élevées aux dimensions faibles. L'action d'initialisation peut se situer n'importe où dans le code, mais la méthode {} ne peut apparaître que là où le tableau est créé. Voir le programme pour la méthode d'initialisation spécifique :
Le code est le suivant :
public class javaArrayInit{ public static void main(String args[]){ int[] arrayA; //未初始化 int[] arrayB = new int[5]; //静态初始化 //System.out.println(arrayA.length); //CompileException System.out.println("arrayB length: " + arrayB.length); //无法得到实际保存的元素个数 arrayA = new int[10]; //动态初始化 System.out.println("arrayA length: " + arrayA.length); int[] arrayC = new int[]{1,2,3,4}; System.out.println("arrayC length: " + arrayC.length); //int[] arrayD = new int[1]{1}; //错误的初始化,不能同时定义维和初始化值 int[][] arrayE = new int[1][]; System.out.println("arrayE length: " + arrayE.length); //int[][] arrayF = new int[][2]; //应先指定高维的长度 int[][] arrayG = new int[][]{{1,2,3,4},{5,6,7},{7,24,23,24}}; System.out.println("arrayG length: " + arrayG.length); int[][][] arrayH = new int[][][]{{{1,2,3},{4,5,6},{7,8,9},{10,11,12}}}; System.out.println("arrayH length: " + arrayH.length); dummyArray[] arrayI = {new dummyArray(),new dummyArray()}; //自定义数组类型 System.out.println("arrayI length: " + arrayI.length); System.out.println("arrayI[1]: " + arrayI[1].getValue()); dummyArray[] arrayK = new dummyArray[5]; System.out.println("arrayK[0]: " + arrayK[0]); //null for(int i = 0; i < arrayK.length; i++){ arrayK[i] = new dummyArray(); } System.out.println("arrayK[0]: " + arrayK[0].getValue()); //2 } } class dummyArray{ private static int temp; private final int arrayValue = temp++; public int getValue(){ return arrayValue; } }
Sortie :
arrayB length: 5 arrayA length: 10 arrayC length: 4 arrayE length: 1 arrayG length: 3 arrayH length: 1 arrayI length: 2 arrayI[1]: 1 arrayK[0]: null arrayK[0]: 2
[longueur]
La longueur du membre en lecture seule est un tableau faisant partie de l'objet (bien que cette variable ne soit pas réellement déclarée dans l'API, elle est générée dynamiquement au moment de l'exécution), c'est le seul champ ou méthode accessible. La syntaxe [] est le seul moyen d'accéder aux objets du tableau, et les conteneurs sont accessibles via la méthode get(). Vous pouvez utiliser Array.length pour obtenir la taille du tableau. Notez qu'elle est différente de String.length() de type String. Array utilise des variables membres, tandis que String utilise des méthodes membres. Dans le même temps, Array.length ne peut obtenir que la taille du tableau, mais pas le nombre d'éléments que le tableau contient réellement. La longueur d'un tableau multidimensionnel calcule uniquement la longueur de la première dimension.
Le code est le suivant :
public class javaArrayLength{ public static void main(String args[]){ int[] arrayA = new int[15]; arrayA[1] = 1; arrayA[2] = 2; arrayA[3] = 3; System.out.println("arrayA length: " + arrayA.length); int[][] arrayB = new int[10][]; System.out.println("arrayB length: " + arrayB.length); int[][] arrayC = new int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7},};//注意后面的逗号 System.out.println("arrayC length: " + arrayC.length); int[][] arrayD = new int[][]{{1,1,1,2,},{1,1,2,3,4,5},{4,5,6,7,7},{}}; System.out.println("arrayD length: " + arrayD.length); } }
Sortie :
arrayA length: 15 arrayB length: 10 arrayC length: 3 arrayD length: 4
[Arrays.fill]
Arrays.fill est une méthode Limited très utile, car elle ne peut remplir que différents emplacements avec la même valeur (ou copier la même référence à remplir dans le cas d'un objet). L'utilisation d'Arrays.fill peut remplir tout le tableau ou une certaine zone du tableau, mais comme Arrays.fill ne peut être appelé qu'avec une seule valeur, ce n'est pas très utile.
[Affectation et référence]
Lorsqu'un tableau JAVA est initialisé, il n'a qu'une référence au tableau et aucun espace de stockage n'est alloué au tableau. Par conséquent, la copie entre tableaux ne peut pas simplement utiliser l'affectation "=", car le même objet est exploité. Le programme suivant :
Le code est le suivant :
public class javaArrayQuote{ public static void main(String args[]){ String testA = "testA"; String testB = "testB"; String[] arrayA = new String[]{"arrayA"}; String[] arrayB = new String[]{"arrayB"}; testB = testA; testB = "testB change"; System.out.println("I'm testA,I have no changed: " + testA); arrayB = arrayA; arrayB[0] = "arrayB have changed"; System.out.println("I'm arrayA, I have no changed: " + arrayA[0]); } }
Sortie :
Je suis testA, je n'ai aucun changement : testA
Je suis arrayA, je n'ai pas changé : arrayB a changé
可以看出,我们改变arrayB[0]的值,改变的是引用的数组,因此我们输出arrayA[0],其实和arrayB[0]一样。
【数组复制】
JAVA中复制数组的方法:
1.使用FOR循环复制全部或指定元素,效率较低
2.使用clone方法,得到数组的值,而不是引用。然而clone不能复制指定元素,灵活性较低
3.使用System.arraycopy(src, srcPos, dest, destPos, length)方法,java标准类库提供有static方法 System.arraycopy(),用它复制数组要比for循环快很多,System.arraycopy()针对所有类型做了重载,基本类型数组和对象数组都可以用System.arraycopy()复制,但是对象数组只是复制引用,不会出现两份对象的拷贝。这被称作浅复制(shallowcopy)。
src:源数组;
srcPos:源数组要复制的起始位置;
dest:目的数组;
destPos:目的数组放置的起始位置;
length:复制的长度.
注意:System.arraycopy()不会进行自动包装和自动拆包,因此两个数组必须是同类型或者可以转换为同类型的数组。同时,这个方法也可以用于复制数组本身。
int[] test ={0,1,2,3,4,5,6};
System.arraycopy(test,0,test,3,3);
则结果为:{0,1,2,0,1,2,6};
测试程序如下:
代码如下:
public class javaArrayCopy{ public static void main(String args[]){ int[] array = {1,2,3,4,5,6,7,8,9}; //for循环方法 int[] arrayA = new int[9]; for(int i = 0; i < arrayA.length; i++){ arrayA[i] = array[i]; System.out.print(arrayA[i] + ","); } //测试 System.out.println(""); arrayA[1] = 19; for(int i = 0; i < arrayA.length; i++){ System.out.print(arrayA[i] + ","); } System.out.println(""); for(int i = 0; i < array.length; i++){ System.out.print(array[i] + ","); } System.out.println(""); //clone方法 int[] arrayB = new int[9]; arrayB = array.clone(); //测试 arrayB[1] = 19; for(int i = 0; i < arrayB.length; i++){ System.out.print(arrayB[i] + ","); } System.out.println(""); for(int i = 0; i < array.length; i++){ System.out.print(array[i] + ","); } System.out.println(""); //System.arrayCopy 方法 int[] arrayC = new int[9]; System.arraycopy(array, 0, arrayC, 0, arrayC.length); //测试 arrayC[1] = 19; for(int i = 0; i < arrayC.length; i++){ System.out.print(arrayC[i] + ","); } System.out.println(""); for(int i = 0; i < array.length; i++){ System.out.print(array[i] + ","); } } }
【数组比较】
Arrays提供了重载后的equals()方法,针对所有类型和Object类型都做了重载,用来比较整个数组。数组相等的条件是元素个数必须相等,并且对应位置的元素也相等。而多维数组的比较用deepEquals()方法。Array.equals()方法比较的两个数组必须是同类型的数组。
代码如下:
import java.util.Arrays; public class javaArrayEquals{ public static void main(String args[]){ int[] arrayA = {1,2,3}; int[] arrayB = {1,2,3,}; int[] arrayC = new int[4]; //if int[] arrayC = new int[3],return true arrayC[0] = 1; arrayC[1] = 2; arrayC[2] = 3; System.out.println(Arrays.equals(arrayA, arrayB)); System.out.println(Arrays.equals(arrayA, arrayC)); String[][] arrayD = {{"a","b"},{"c","d"}}; String[][] arrayE = {{"a","b"},{"c","d"}}; System.out.println(Arrays.deepEquals(arrayD, arrayE)); } }
【数组排序与查找】
数组提供了内置的排序方法sort(),可以对任意基本类型数组或者对象数组进行排序(该对象必须实现Comparable接口或者具有相关联的Comparator)。JAVA对不同的类型提供了不同的排序方法----针对基本类型设计的快速排序,以及针对对象设计的“稳定归并排序”,所以无需担心数组排序的效率问题。
binarySearch()用于在以排好序的数组中快速查找元素,如果对未排序的数组使用binarySearch(),那么将产生难以预料的结果。
【返回数组】
C和C++不能返回一个数组,只能返回指向数组的指针,因为返回数组使得控制数组的生命周期变得困难,并且容易造成内存泄漏。java允许直接返回一个数组,并且可以由垃圾回收机制回收。
【数组与容器转换】【无法转换基本类型数组】
数组转为List:
代码如下:
import java.util.*; public class arrayToList{ public static void main(String args[]){ String[] arrayA = {"a","b","c"}; List listA = java.util.Arrays.asList(arrayA); System.out.println("listA: " + listA); int[] arrayB = {1,2,3}; List listB = java.util.Arrays.asList(arrayB); System.out.println("listB: " + listB); Integer[] arrayC = {1,2,3}; List listC = java.util.Arrays.asList(arrayC); System.out.println("listC: " + listC); } }
输出:
listA: [a, b, c] listB: [[I@de6ced] listC: [1, 2, 3]
为什么int和Integer输出会不同呢?
List转为数组
代码如下:
import java.util.*; public class listToArray{ public static void main(String args[]){ List<String> list = new ArrayList<String>(); String[] array; list.add("testA"); list.add("testB"); list.add("testC"); System.out.println("list: " + list); String[] strings = new String[list.size()]; array = list.toArray(strings); for(int i = 0, j = array.length; i < j; i++){ System.out.print(array[i] + ","); } } }
输出为:
list: [testA, testB, testC]
testA,testB,testC
【去除重复数据】
利用数组和容器转换可以方便地去除数组重复数据,不过如果数组过大,效率是一个问题。
代码如下:
import java.util.*; public class javaArrayUnique{ public static void main(String args[]){ String[] array = {"a","b","a","a","c","b"}; arrayUnique(array); //test for(int i = 0, j = arrayUnique(array).length; i < j; i++){ System.out.print(arrayUnique(array)[i] + ","); } } public static String[] arrayUnique(String[] array){ List<String> list = new ArrayList<String>(); for(int i = 0, j = array.length; i < j; i++){ if(!list.contains(array[i])){ list.add(array[i]); } } String[] strings = new String[list.size()]; String[] arrayUnique = list.toArray(strings); return arrayUnique; } }
关于效率问题,我做了一个对比,在我电脑上运行十万数据的数组大概是577ms,而运行一百万数据的数据大约要5663ms。这还跟计算机的运行能力有关,但是明显是随着数组大小递增的。
代码如下:
import java.util.*; public class javaArrayUnique{ public static void main(String args[]){ Double[] array = new Double[100000]; for(int i = 0, j = array.length; i < j; i++){ array[i] = Math.ceil(Math.random()*1000); } Double[] arrayB = new Double[1000000]; for(int i = 0, j = arrayB.length; i < j; i++){ arrayB[i] = Math.ceil(Math.random()*1000); } System.out.println("start"); long startTime = System.currentTimeMillis(); arrayUnique(array); long endTime = System.currentTimeMillis(); System.out.println("array unique run time: " +(endTime - startTime) +"ms"); long startTimeB = System.currentTimeMillis(); arrayUnique(arrayB); long endTimeB = System.currentTimeMillis(); System.out.println("arrayB unique run time: " +(endTimeB - startTimeB) +"ms"); } public static Double[] arrayUnique(Double[] array){ List<Double> list = new ArrayList<Double>(); for(int i = 0, j = array.length; i < j; i++){ if(!list.contains(array[i])){ list.add(array[i]); } } Double[] doubles = new Double[list.size()]; Double[] arrayUnique = list.toArray(doubles); return arrayUnique; } }
输出:
startarray unique run time: 577msarrayB unique run time: 5663ms
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!