关于java中的toArray()方法动态数组的运用？？？？？？？

Posted 2023-05-09

public static void FCFS(ArrayList<Process[]> list)
Process []p=(Process[])list.toArray(new Process[0]);
// Object a[]=list.toArray();
// Process []p=(Process[])a;
Arrays.sort(p);
System.out.println("FCFS的调度结果是：");
for (int i = 0; i < p.length; i++)
System.out.print(p[i].name+" ");


public static void main(String[] args)
ArrayList<Process[]> list=new ArrayList<Process[]>();
Process p[] = new Process[5];
p[0] = new Process("A",0,4,2);
p[1] = new Process("B",1,3,6);
p[2] = new Process("C",2,5,9);
p[3] = new Process("D",3,2,4);
p[4] = new Process("E",4,4,5);
list.add(p);
FCFS(list);
我就是想把数组变为动态的，然后传到FCFS()方法中调用，以便以后可能会对数组进行扩充。但是我上面的实现有问题，不能编译成功，有没有高手可以指教一下，谢谢！！
最好，再创建一个对象数组，然后加进去，但是是作为另一个函数的参数，求解？

public class Process
public String name;
public int a,b,c;

public Process()
// TODO Auto-generated constructor stub


public Process(String name,int a,int b,int c)
this.name=name;
this.a=a;
this.b=b;
this.c=c;

public String getname()
return name;

public void setname(String name)
this.name=name;

public String toString()
return this.name+this.a+this.b+this.c;


import java.util.ArrayList;
import java.util.Arrays;

public class FCFS
public static void FCFS(ArrayList<Process> list)

Object []pr=list.toArray();
System.out.println("FCFS的调度结果是：");
for (int i = 0; i < pr.length; i++)
System.out.print(((Process)pr[i]).getname()+" ");


public static void main(String[] args)
ArrayList<Process> list=new ArrayList<Process>();
Process p0 = new Process("A",0,4,2);
Process p1 = new Process("B",1,3,6);
Process p2 = new Process("C",2,5,9);
Process p3 = new Process("D",3,2,4);
Process p4 = new Process("E",4,4,5);
list.add(p0);
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);

FCFS(list);


或者改成：
public class Process
public String name;
public int a,b,c;

public Process()
// TODO Auto-generated constructor stub


public Process(String name,int a,int b,int c)
this.name=name;
this.a=a;
this.b=b;
this.c=c;

public String getname()
return name;

public void setname(String name)
this.name=name;

public String toString()
return this.name+this.a+this.b+this.c;


import java.util.ArrayList;
import java.util.Arrays;

public class FCFS
public static void FCFS(ArrayList<Process[]> list)
　　　 Process []p=(Process[])list.get(0);
System.out.println("FCFS的调度结果是：");
for (int i = 0; i < p.length; i++)
System.out.print(p[i].getname()+" ");


public static void main(String[] args)
ArrayList<Process[]> list=new ArrayList<Process[]>();
Process p[] = new Process[5];
p[0] = new Process("A",0,4,2);
p[1] = new Process("B",1,3,6);
p[2] = new Process("C",2,5,9);
p[3] = new Process("D",3,2,4);
p[4] = new Process("E",4,4,5);
list.add(p);

FCFS(list);

追问

那往里面加一个数组怎么弄啊？
Process p2[]=new Process[1];
p2[0]=new Process("F",5,3,3);
list.add(p2);
RobPriority(list);
我想把这个加入list中，然后调用另一个方法，用多了p[2]的这个数组作参数，但是好像list.add()这个方法不管用了，能不能帮忙解决一下啊，可以给你加分，看着前面那个做的挺对的，谢谢了

追答

Process类不变，主程序改成如下：
import java.util.ArrayList;
import java.util.Arrays;

public class FCFS
public static void FCFS(ArrayList list)

Process []p=(Process[])list.get(0);
Process []p1=(Process[])list.get(1);
System.out.println("FCFS的调度结果是：");
for (int i = 0; i list=new ArrayList();
Process p[] = new Process[5];
p[0] = new Process("A",0,4,2);
p[1] = new Process("B",1,3,6);
p[2] = new Process("C",2,5,9);
p[3] = new Process("D",3,2,4);
p[4] = new Process("E",4,4,5);
list.add(p);

Process p2[]=new Process[2];
p2[0]=new Process("F",5,3,3);
p2[1]=new Process("G",3,2,1);
list.add(p2);
FCFS(list);

参考技术A 不能处理数组...
ArrayList<Process> list=new ArrayList<Process>();
list.add(p[0]);
list.add(p[1]);
list.add(p[2]);
。。。

这样才行，不支持数组，如：ArrayList<Process[]> list=new ArrayList<Process[]>();
实现机制决定的 参考技术B 为什么不把数组也换成ArrayList呢？这样的话就能放进ArrayList里了

Stream将Java流转化成数组

Java流转换为数组最好的方法是使用 Stream.toArray (IntFunction) 方法。

我们将通过以下方式将Java流(Stream)转换为数组(Array)。

1. 我们将使用 Stream.toArray (IntFunction) 返回所需类型的数组。

2. 使用 Stream.toArray (IntFunction) 方法返回Object[] ，然后将其更改为所需的数据类型。

3. 对于整数流，我们可以使用IntStream.toArray()将返回int[]。我们可以用同样的方法LongStream.toArray() 返回long[]和DoubleStream.toArray()返回double[]。

4. 我们可以将流转换成列表,然后将列表转换为数组。要将流转换为列表，我们需要在流上使用 collect(Collectors.toList()) ，将列表转换为数组，我们可以使用 List.toArray 方法。

1. 使用Stream.toArray (IntFunction)

toArray（IntFunction）方法使用提供的生成器作为IntFunction返回包含此流元素的数组。这个方法是终端的操作。

A[] toArray(IntFunction<A[]> generator)

参数: 将生成器作为IntFunction传递，该函数生成所需类型和所提供长度的新数组。

返回: 该方法返回由stream元素组成的数组。

抛出: 如果此流中任何元素的运行时类型不可分配给生成数组的运行时组件类型，则该方法将抛出ArrayStoreException。

示例1:

在这个例子中我们将字符串流转换成字符串的数组。

List<String> list = Arrays.asList("A", "B", "C", "D");
String[] strArray = list.stream().toArray(String[]::new);
for(String s : strArray) {
  System.out.println(s);
} 

输出为A B C D。 在上面的示例中，我们使用方法引用将IntFunction实例化为toArray方法中的生成器。

lambda表达式的例子。

String[] strArray = list.stream().toArray(size -> new String[size]);

再看一个例子

public class StreamToStringArray {
  public static void main(String[] args) {
     List<String> list = Arrays.asList("Krishna", "Mahesh", "Kush");
     String[] strArray = list.stream()
    	 .filter(e -> e.startsWith("K"))
    	 .toArray(size -> new String[size]);
     for(String s : strArray) {
       System.out.println(s);
     }
  }
} 

输出

Krishna
Kush 

示例2:

在这个例子中我们将整数流转换为整数数组。

public class StreamToIntegerArray {
  public static void main(String[] args) {
     List<Integer> list = Arrays.asList(10, 20, 30, 40);
     Integer[] intArray = list.stream()
    	 .map(e -> e * 2)
    	 .toArray(Integer[]::new);
     for(Integer i : intArray) {
       System.out.println(i);
     }
  }
} 

输出为20 40 60 80。

在上面的例子中我们使用了方法引用。

现在使用lambda表达式。

List<Integer> list = Arrays.asList(10, 20, 30, 40);
Integer[] intArray = list.stream()
  .map(e -> e * 2)
  .toArray(size -> new Integer[size]); 

2. 使用Stream.toArray ()

 toArray () 方法返回一个包含此流元素的Object数组。

Object[] toArray()

这个方法是终端的操作。

示例1: 

在这个例子中,我们将一串字符串转换成字符串的数组。 我们知道toArray()返回Object[]，所以为了在我们需要的数据类型中转换它，我们可以使用Arrays.copyOf方法。

Object[] objArray = Stream.of("AA", "BB", "CC").toArray();
String[] stArray = Arrays.copyOf(objArray, objArray.length, String[].class);

for(String s : stArray) {
  System.out.println(s);
} 

输出为 AA BB CC。

示例2: 

在这个例子中我们将整数流转换为整数的数组。

Object[] objArray = Stream.of(10, 20, 30, 40).toArray();
Integer[] intArray = Arrays.copyOf(objArray, objArray.length, Integer[].class);

for(Integer i : intArray) {
  System.out.println(i);
} 

输出为10 20 30 40。

3. 使用IntStream.toArray ()

IntStream是int-valued元素的流。IntStream.toArray()方法将int值流转换为int数组。

int[] toArray()

我们可以通过以下三种方式获得IntStream对象

1.IntStream intStream = IntStream.of(1,2,3,4,5);

2.IntStream intStream = IntStream.rangeClosed(1, 5);

3.IntStream intStream = Stream.of(4,5,6,7,8).mapToInt(i -> i);

现在让我们来看一些使用IntStream.toArray()方法的例子。

示例1:

int[] intArray = IntStream.of(10, 20, 30, 40).toArray();
for(Integer i : intArray) {
  System.out.println(i);
} 

输出是10 20 30 40。

示例2:

int[] intArray = IntStream.rangeClosed(10, 15).toArray();
for(Integer i : intArray) {
  System.out.println(i);
} 

输出是10 11 12 13 14 15。

示例3:

int[] intArray = Stream.of(3,4,5,6).mapToInt(i -> i * 2).toArray();
for(Integer i : intArray) {
  System.out.println(i);
} 

输出是6 8 10 12。

4. 使用Collectors.toList ()

我们可以将流转换成列表,然后将列表转换成数组。要将stream转换成list，我们需要对stream使用collect(Collectors.toList())。为了将list转换成array，我们可以使用List.toArray方法。

public class StreamToListToArray {
  public static void main(String[] args) {
	System.out.println("--- For String ---");
	String[] ar = Stream.of("Java", "Angular", "Spring")
		.collect(Collectors.toList())
		.toArray(new String[0]);
	
	for(String e : ar) {
	    System.out.println(e);	  
	}
	
	System.out.println("--- For Integer ---");
	Integer[] intArray = Stream.of(15, 20, 30)
		.map(e -> e * 2)
		.collect(Collectors.toList())
		.toArray(new Integer[0]);
	
        for(Integer i : intArray) {
            System.out.println(i);
        }	
  }
} 

输出

--- For String ---
Java
Angular
Spring
--- For Integer ---
30
40
60 

参考：

https://www.concretepage.com/java/java-8/convert-java-stream-to-array

https://blog.csdn.net/qq_31635851/article/details/111145708