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指向了这个堆中的对象。