Ik heb een klasse – xClass, die ik in een array van xClass wil laden, dus ik de verklaring:
xClass mysclass[] = new xClass[10];
myclass[0] = new xClass();
myclass[9] = new xClass();
Ik weet echter niet of ik er 10 nodig heb. Misschien heb ik er 8 of 12 of een ander nummer nodig. Ik weet het pas tijdens runtime.
Kan ik het aantal elementen in een array on-the-fly wijzigen?
Zo ja, hoe?
Antwoord 1, autoriteit 100%
Nee, u kunt de grootte van een array niet wijzigen nadat deze is gemaakt. Je moet het ofwel groter toewijzen dan je denkt nodig te hebben, of de overhead accepteren die nodig is om het opnieuw te moeten toewijzen om in omvang te groeien. Als dit het geval is, moet u een nieuwe toewijzen en de gegevens van de oude naar de nieuwe kopiëren:
int[] oldItems = new int[10];
for (int i = 0; i < 10; i++) {
oldItems[i] = i + 10;
}
int[] newItems = new int[20];
System.arraycopy(oldItems, 0, newItems, 0, 10);
oldItems = newItems;
Als u zich in deze situatie bevindt, raad ik u ten zeerste aan om in plaats daarvan de Java-verzamelingen te gebruiken. In het bijzonder ArrayListverpakt in wezen een array en zorgt voor de logica om de array naar wens te laten groeien:
List<XClass> myclass = new ArrayList<XClass>();
myclass.add(new XClass());
myclass.add(new XClass());
Over het algemeen is een ArrayListhoe dan ook een oplossing die de voorkeur heeft boven een array om verschillende redenen. Om te beginnen zijn arrays veranderlijk. Als je een klas hebt die dit doet:
class Myclass {
private int[] items;
public int[] getItems() {
return items;
}
}
heb je een probleem ontstaan als een beller kan uw persoonlijke gegevens lid, wat leidt tot allerlei defensieve kopiëren veranderen. Vergelijk dit met de versie List:
class Myclass {
private List<Integer> items;
public List<Integer> getItems() {
return Collections.unmodifiableList(items);
}
}
2, Autoriteit 15%
java arraylengte gefixeerd.
U kunt een lijst gebruiken om de waarden vast te houden en een beroep doen op de toArraymethode, indien nodig
Zie het volgende voorbeeld:
import java.util.List;
import java.util.ArrayList;
import java.util.Random;
public class A {
public static void main( String [] args ) {
// dynamically hold the instances
List<xClass> list = new ArrayList<xClass>();
// fill it with a random number between 0 and 100
int elements = new Random().nextInt(100);
for( int i = 0 ; i < elements ; i++ ) {
list.add( new xClass() );
}
// convert it to array
xClass [] array = list.toArray( new xClass[ list.size() ] );
System.out.println( "size of array = " + array.length );
}
}
class xClass {}
3, Autoriteit 5%
Zoals anderen al hebben gezegd, je kunt niet de grootte van een bestaande Java-array te wijzigen.
ArrayList ligt het dichtst dat standaard Java moet een dynamisch bemeten array. Echter, er zijn een paar dingen over ArrayList (eigenlijk de List interface) die niet zijn “serie zoals”. Bijvoorbeeld:
- Je kunt
[ ... ]niet gebruiken om een lijst te indexeren. U moet de methodenget(int)enset(int, E)gebruiken. - Er wordt een ArrayList gemaakt met nul elementen. U kunt niet eenvoudig een ArrayList maken met 20 elementen en vervolgens
set(15, foo)aanroepen. - U kunt de grootte van een ArrayList niet rechtstreeks wijzigen. U doet dit indirect met behulp van de verschillende methoden
add,insertenremove.
Als u iets meer array-achtigs wilt, moet u uw eigen API ontwerpen. (Misschien kan iemand inhaken op een bestaande bibliotheek van derden … Ik kon er geen vinden met 2 minuten “onderzoek” met Google 🙂 )
Als je echt alleen een array nodig hebt die aangroeit terwijl je hem initialiseert, dan is de oplossing zoiets als dit.
ArrayList<T> tmp = new ArrayList<T>();
while (...) {
tmp.add(new T(...));
}
// This creates a new array and copies the element of 'tmp' to it.
T[] array = tmp.toArray(new T[tmp.size()]);
Antwoord 4, autoriteit 4%
Je stelt het aantal elementen in op alles wat je wilt op het moment dat je het maakt:
xClass[] mysclass = new xClass[n];
Vervolgens kunt u de elementen in een lus initialiseren. Ik vermoed dat dit is wat je nodig hebt.
Als u elementen aan de array moet toevoegen of verwijderen nadat u deze hebt gemaakt, moet u een ArrayListgebruiken.
Antwoord 5, autoriteit 3%
U kunt ArrayList gebruiken:
import java.util.ArrayList;
import java.util.Iterator;
…
ArrayList<String> arr = new ArrayList<String>();
arr.add("neo");
arr.add("morpheus");
arr.add("trinity");
Iterator<String> foreach = arr.iterator();
while (foreach.hasNext()) System.out.println(foreach.next());
6, Autoriteit 2%
Zoals andere gebruikers zeggen, heb je waarschijnlijk een implementatie van java.util.list nodig.
Als u om een of andere reden uiteindelijk een array nodig hebt, kunt u twee dingen doen:
-
Gebruik een lijst en converteer het naar een array met mylist.toarray ()
-
Gebruik een reeks van een bepaalde grootte. Als u meer of minder grootte nodig heeft, kunt u het wijzigen met Java.Util.arrays-methoden.
De beste oplossing is afhankelijk van uw probleem;)
7, Autoriteit 2%
Arrays.copyOf()METHODE HEEFT VEEL OPTIES OM HET PROBLEEM TE CONFROLEER MET ARRAY LANGLEN DIE DYNAYAAL TOEPASSEN.
8
Ja, wikkel het en gebruik het Collections Framework.
List l = new ArrayList();
l.add(new xClass());
// do stuff
l.add(new xClass());
Gebruik vervolgens Lijst.toArray () indien nodig, of alleen het herhalen van de lijst.
9
Ik raad in plaats daarvan de vectoren aan. Zeer eenvoudig te gebruiken en heeft vele vooraf gedefinieerde methoden voor implementatie.
import java.util.*;
Vector<Integer> v=new Vector<Integer>(5,2);
Om een element toe te voegen, gebruikt u eenvoudig:
v.addElement(int);
In de (5,2)is de eerste 5 de initiële grootte van de vector. Als u de oorspronkelijke grootte overschrijdt, groeit de vector met 2 plaatsen. Als het weer overschrijdt, wordt het weer met 2 plaatsen verhoogd, enzovoort.
Antwoord 10
Waar je de myclass[] array declareert als :
xClass myclass[] = new xClass[10]
, geef als argument gewoon het aantal XClass-elementen dat je nodig hebt. Weet je op dat moment hoeveel je er nodig hebt? Door te declareren dat de array 10 elementen heeft, declareert u geen 10 XClass-objecten, maar maakt u eenvoudig een array met 10 elementen van het type xClass.
Antwoord 11
Java-array-groottes zijn vast, u kunt geen dynamische arrays maken zoals in C++.
Antwoord 12
Omdat ArrayList te veel geheugen in beslag neemt wanneer ik een reeks primitieve typen nodig heb, gebruik ik liever IntStream.builder() voor het maken van int-array (u kunt ook LongStream- en DoubleStream-builders gebruiken).
Voorbeeld:
Builder builder = IntStream.builder();
int arraySize = new Random().nextInt();
for(int i = 0; i<arraySize; i++ ) {
builder.add(i);
}
int[] array = builder.build().toArray();
Opmerking: beschikbaar sinds Java 8.
13
Ik weet niet of u de grootte op runtime kunt wijzigen, maar u kunt de grootte bij runtime toewijzen. Probeer deze code te gebruiken:
class MyClass {
void myFunction () {
Scanner s = new Scanner (System.in);
int myArray [];
int x;
System.out.print ("Enter the size of the array: ");
x = s.nextInt();
myArray = new int[x];
}
}
Hiermee wordt uw array-formaat wijst als die wordt ingevoerd op looptijd in X.
14
Hier is een methode die geen arrayclist gebruikt. De gebruiker geeft de grootte aan en u kunt een do-while-lus toevoegen voor recursie.
import java.util.Scanner;
public class Dynamic {
public static Scanner value;
public static void main(String[]args){
value=new Scanner(System.in);
System.out.println("Enter the number of tests to calculate average\n");
int limit=value.nextInt();
int index=0;
int [] marks=new int[limit];
float sum,ave;
sum=0;
while(index<limit)
{
int test=index+1;
System.out.println("Enter the marks on test " +test);
marks[index]=value.nextInt();
sum+=marks[index];
index++;
}
ave=sum/limit;
System.out.println("The average is: " + ave);
}
}
Antwoord 15
In Java hebben arrayformaten altijd een vaste lengte, maar er is een manier waarop u de grootte van de array dynamisch kunt vergroten tijdens runtime zelf
Dit is zowel de meest “gebruikte” als de geprefereerde manier om het te doen-
int temp[]=new int[stck.length+1];
for(int i=0;i<stck.length;i++)temp[i]=stck[i];
stck=temp;
In de bovenstaande code initialiseren we een nieuwe temp[]-array en gebruiken we verder een for-lus om de inhoud van de temp te initialiseren met de inhoud van de originele array, dwz. stk[]. En dan opnieuw kopiëren naar de originele, waardoor we een nieuwe reeks nieuwe SIZE krijgen.
Het genereert ongetwijfeld een CPU-overhead vanwege het herhaaldelijk opnieuw initialiseren van een array met de for-lus. Maar u kunt het nog steeds gebruiken en implementeren in uw code.
Gebruik voor de best practice “Linked List” in plaats van Array, als u wilt dat de gegevens dynamisch in het geheugen worden opgeslagen, van variabele lengte.
Hier is een realtime voorbeeld op basis van dynamische stapels om de ARRAY-GROOTTE tijdens runtime te VERHOGEN
Bestandsnaam: DStack.java
public class DStack {
private int stck[];
int tos;
void Init_Stck(int size) {
stck=new int[size];
tos=-1;
}
int Change_Stck(int size){
return stck[size];
}
public void push(int item){
if(tos==stck.length-1){
int temp[]=new int[stck.length+1];
for(int i=0;i<stck.length;i++)temp[i]=stck[i];
stck=temp;
stck[++tos]=item;
}
else
stck[++tos]=item;
}
public int pop(){
if(tos<0){
System.out.println("Stack Underflow");
return 0;
}
else return stck[tos--];
}
public void display(){
for(int x=0;x<stck.length;x++){
System.out.print(stck[x]+" ");
}
System.out.println();
}
}
Bestandsnaam: Exec.java
(met de hoofdklas)
import java.util.*;
public class Exec {
private static Scanner in;
public static void main(String[] args) {
in = new Scanner(System.in);
int option,item,i=1;
DStack obj=new DStack();
obj.Init_Stck(1);
do{
System.out.println();
System.out.println("--MENU--");
System.out.println("1. Push a Value in The Stack");
System.out.println("2. Pop a Value from the Stack");
System.out.println("3. Display Stack");
System.out.println("4. Exit");
option=in.nextInt();
switch(option){
case 1:
System.out.println("Enter the Value to be Pushed");
item=in.nextInt();
obj.push(item);
break;
case 2:
System.out.println("Popped Item: "+obj.pop());
obj.Change_Stck(obj.tos);
break;
case 3:
System.out.println("Displaying...");
obj.display();
break;
case 4:
System.out.println("Exiting...");
i=0;
break;
default:
System.out.println("Enter a Valid Value");
}
}while(i==1);
}
}
Ik hoop dat dit je vraag oplost.
Antwoord 16
Ja, we kunnen het op deze manier doen.
import java.util.Scanner;
public class Collection_Basic {
private static Scanner sc;
public static void main(String[] args) {
Object[] obj=new Object[4];
sc = new Scanner(System.in);
//Storing element
System.out.println("enter your element");
for(int i=0;i<4;i++){
obj[i]=sc.nextInt();
}
/*
* here, size reaches with its maximum capacity so u can not store more element,
*
* for storing more element we have to create new array Object with required size
*/
Object[] tempObj=new Object[10];
//copying old array to new Array
int oldArraySize=obj.length;
int i=0;
for(;i<oldArraySize;i++){
tempObj[i]=obj[i];
}
/*
* storing new element to the end of new Array objebt
*/
tempObj[i]=90;
//assigning new array Object refeence to the old one
obj=tempObj;
for(int j=0;j<obj.length;j++){
System.out.println("obj["+j+"] -"+obj[j]);
}
}
}
Antwoord 17
Je kunt iets doen
private static Person [] addPersons(Person[] persons, Person personToAdd) {
int currentLenght = persons.length;
Person [] personsArrayNew = Arrays.copyOf(persons, currentLenght +1);
personsArrayNew[currentLenght] = personToAdd;
return personsArrayNew;
}