java分派

⑴ 求助：java中怎麼實現按比例隨機分配

比如有十個糖果，按照2:3:5的比例分配給三個小孩

publicclassluck{

	publicstaticList<String>candy=newArrayList<String>();
	publicstaticList<String>child1=newArrayList<String>();
	publicstaticList<String>child2=newArrayList<String>();
	publicstaticList<String>child3=newArrayList<String>();

	//2：3：5
	publicstaticvoidmain(String[]args){
		candy.add("糖果1");
		candy.add("糖果2");
		candy.add("糖果3");
		candy.add("糖果4");
		candy.add("糖果5");
		candy.add("糖果6");
		candy.add("糖果7");
		candy.add("糖果8");
		candy.add("糖果9");
		candy.add("糖果10");
		intcount=10;
		for(inti=0;i<2;i++){
			intmath=(int)(Math.random()*count);
			child1.add(candy.get(math));
			candy.remove(math);
			count--;
		}
		for(inti=0;i<3;i++){
			intmath=(int)(Math.random()*count);
			child2.add(candy.get(math));
			candy.remove(math);
			count--;
		}
		for(inti=0;i<5;i++){
			intmath=(int)(Math.random()*count);
			child3.add(candy.get(math));
			candy.remove(math);
			count--;
		}
		System.out.println("child1的糖:");
		for(inti=0;i<child1.size();i++){
			System.out.println(child1.get(i));
		}
		System.out.println("child2的糖:");
		for(inti=0;i<child2.size();i++){
			System.out.println(child2.get(i));
		}
		System.out.println("child3的糖:");
		for(inti=0;i<child3.size();i++){
			System.out.println(child3.get(i));
		}

	}

}

輸出結果:

child1的糖:

糖果6

糖果1

child2的糖:

糖果7

糖果2

糖果8

child3的糖:

糖果4

糖果3

糖果10

糖果5

糖果9

⑵ 怎樣用java實現內存動態分配

1、java是如何管理內存的

Java的內存管理就是對象的分配和釋放問題。（兩部分）
分配 ：內存的分配是由程序完成的，程序員需要通過關鍵字new 為每個對象申請內存空間 (基本類型除外)，所有的對象都在堆 (Heap)中分配空間。
釋放 ：對象的釋放是由垃圾回收機制決定和執行的，這樣做確實簡化了程序員的工作。但同時，它也加重了JVM的工作。因為，GC為了能夠正確釋放對象，GC必須監控每一個對象的運行狀態，包括對象的申請、引用、被引用、賦值等，GC都需要進行監控。
2、 JVM的內存區域組成
java把內存分兩種：一種是棧內存，另一種是堆內存1。在函數中定義的基本類型變數和對象的引用變數都在函數的棧內存中分配；2。堆內存用來存放由new創建的對象和數組以及對象的實例變數 在函數（代碼塊）中定義一個變數時，java就在棧中為這個變數分配內存空間，當超過變數的作用域後，java會自動釋放掉為該變數所分配的內存空間；在堆中分配的內存由java虛擬機的自動垃圾回收器來管理
堆和棧的優缺點
堆的優勢是可以動態分配內存大小，生存期也不必事先告訴編譯器，因為它是在運行時動態分配內存的。
缺點就是要在運行時動態分配內存，存取速度較慢； 棧的優勢是，存取速度比堆要快，僅次於直接位於CPU中的寄存器。
另外，棧數據可以共享。但缺點是，存在棧中的數據大小與生存期必須是確定的，缺乏靈活性。

⑶ Java的內存分配是什麼樣的

關於java內存分配是這樣的：
程序代碼存儲在"code segment"中，靜態變數和字元串常量存儲在「data segment"區域中，局部變數存儲在"stack"(棧內存）中，nwe出來的東西（即對象）存儲在"heap"(堆內存）中

⑷ 怎樣理解Java靜態分派和動態分派

靜態就是事先已經寫好的，動態的是根據需要來分派

⑸ java隨機分配！比如有五個座位a, b, c ,d ,e，有五個學生1,2,3,4,5 把學生分配到座位上不能有重復！求代碼

import java.util.*;
public class a {
public static void main(String[] args) {
int i;
char c;
String[] a = {"座位1","座位2","座位3","座位4","座位5"};
/*生成座位list*/
List<String> seat = new ArrayList<String>();
/*向其中添加座位*/
for(i = 0;i < 5;i++){
seat.add(a[i]);
}

/*調用函數，將順序打亂*/
Collections.shuffle(seat);

/*顯示結果*/
for(i = 0,c = 'a'; c <= 'e';c++,i++){
System.out.println("學生"+c+"坐在"+seat.get(i));
}
}
}

有問題追問我

⑹ java的內存分配和c#的內存分配一樣嗎

int noBB="sayWordsICAN undstand";
noBB存在棧里，是對堆中的對象的引用。
等號後面的就是堆中的對象。
棧和堆都是數據結構，是在內存中分配的一塊空間。
C和java，還有其他語言的空間分配和管理方式可能是不一樣的，雖然可能都有堆棧的概念。
java是由jvm管理堆棧，不用程序員手動釋放內存。而c就要手動去釋放

⑺ 如何理解java是一門靜態多分派且動態單分派的語言

C++, Java 都是單分派語言。

有人把 Java 的重載說成是「靜態多分派」，有待商榷。重載是在編譯時決定要用哪個函數，是靜態的，而一般來說，分派常常是指在運行時，如何決定調用哪個函數，是動態的。

單分派所調用的函數，由單個量決定，常常是被調用的Object 的實際類型，而不考慮傳入參數的實際類型。但多分派，通常會考慮傳入參數的實際類型。當然，具體細節在各個語言中還有不同。

舉個例子，在Java中，先創建三個類， Fruit, Apple, Banana, 當然，apple，banana，是 Fruit 的子類。
class Fruit{
}

class Apple extends Fruit{
}

class Banana extends Fruit{
}

再創建兩個類，People, Boy。Boy是People的子類，並 override People中的三個method.

class People{
public void eat(Fruit f)
{
System.out.println("People eat Fruit");
}
public void eat(Apple f)
{
System.out.println("People eat Apple");
}
public void eat(Banana f)
{
System.out.println("People eat Banana");
}
}

class Boy extends People{
public void eat(Fruit f)
{
System.out.println("Boy eats Fruit");
}
public void eat(Apple f)
{
System.out.println("Boy eats Apple");
}
public void eat(Banana f)
{
System.out.println("Boy eats Banana");
}

再來個main()，看看print 出來的是什麼。
public static void main(String[] argu)
{
People boy = new Boy();
Fruit apple = new Apple();
Fruit banana = new Banana();

boy.eat(apple);
boy.eat(banana);
}

結果是：
Boy eats Fruit
Boy eats Fruit

分派發生在此，「boy」被聲明為People，但調用的依然是Boy的函數，也就是所謂的多態。但是，雖然傳入的參數"apple"的實際類型是Apple，但調用的函數依然是Boy的「 public void eat(Fruit f)」，不是「 public void eat(Apple f)」。運行時，Java參數的實際類型不影響分派，這就是單分派了。

⑻ java中內存的分配問題

根據樓主的描述，感覺樓主的思想還停留在面向過程的層面上，對於java這樣的純面向對象的語言的語法和調用機制感到迷茫。這是很正常的，面向對象和面向過程本來就是兩個東西，從面向過程轉到面向對象，確實有點困難。
在你的問題中，你說「為什麼在main方法中，必須為屬性賦值或創建對象才能列印輸出，而在前一個類的方法中可以直接列印輸出呢？」，這個問題證明了你對java中「類」和對象的概念沒有理解清楚，首先，name屬性石類Stu的成員變數，許可權為public，因此任何類Stu的實例都可以通過.來引用該成員，但是其他類無法繞過Stu及其對象而引用該屬性(其實應該這么說，面向對象的語言中，沒有面向過程的語言中所謂的『全局變數』，定義一個變數，該變數必須屬於某個類的，在java中也肯定是屬於某個類的，而不能是如你所想的那樣，某個類中定義一個變數，任何類都可以繞過其所在類直接使用變數名來引用該變數，這是不可能實現的)。
舉個例子來講，你(類Stu)可以使用自己的手（變數name），來做任何事（System.out.println(name)），因為對於你來說手是你自己的，因此可以自由使用，這是憲法（JVM）賦予你（任何類）的自由權利但是對於其他人（類test）來說，如果要使用你的手（System.out.println(name+"\t"+a+"\t"+stu.name)），必須通過你（Stu.name），才能使用，難道你見過別人請你幫忙的時候，只帶走了你的手，而沒有把你帶走嗎？
關於虛擬機在執行Why y = new Why();代碼時，是如何分配內存的，一樓已經回答的很清楚了，我就不再贅述了。
最後，建議樓主多看看java入門，好好理解面向對象的思想，這一點無論是剛入門，還是日後你成為技術大牛，做架構設計，這一點都是至關重要的，至少在java世界中是這樣的。

⑼ 怎麼給java分配內存

方法如下： 1、打開eclipse配置文件eclipse.ini，更改把-Xmx（其數值代表jvm可以使用的最大內存數） 2、運行java程序時，選擇run->run configuration->arguments,輸入-Xms100M -Xmx800M（-Xms代表jvm啟動時分配的內存大小，-Xmx代表可最大分配

⑽ 關於java內存分配問題

對於Person p = new Person();
1.
Person p中的Person用來指定引用類型的變數p的類型，變數p一般存放在棧中，如果是作為其它類的屬性也可存放在堆中，如：
class C
{
Person p = new Person();
}
2.
new Person()會在堆中創建一個Person類的對象並調用Person類的默認構造器初始化這個對象，然後返回這個對象的引用（可以理解為指針或句柄）。
3.
=將new Person()返回的引用賦值給變數p，p指向了這個堆中的對象。