java分配算法
总共150响，代码如下
public static void main(String[] args) {
Map<Integer,String> bombCount = new HashMap<Integer, String>();
for (int i = 1; i <= 100; i++) {
Integer aBombTime = 1*i;
Integer bBombTime = 2*i;
Integer cBombTime = 3*i;
String tempA = bombCount.get(aBombTime);
if(tempA == null){
bombCount.put(aBombTime, "a");
}
String tempB = bombCount.get(bBombTime);
if(tempB == null){
bombCount.put(bBombTime, "a");
}
String tempC = bombCount.get(bBombTime);
if(tempC == null){
bombCount.put(cBombTime, "a");
}
}
System.out.println("All bomb count = " + bombCount.size());
}
‘贰’ java常见gc算法有哪些
1：标记—清除 Mark-Sweep
过程：标记可回收对象，进行清除
缺点：标记和清除效率低，清除后会产生内存碎片
2：复制算法
过程：将内存划分为相等的两块，将存活的对象复制到另一块内存，把已经使用的内存清理掉
缺点：使用的内存变为了原来的一半
进化：将一块内存按8:1的比例分为一块Eden区（80%）和两块Survivor区（10%）
每次使用Eden和一块Survivor，回收时，将存活的对象一次性复制到另一块Survivor上，如果另一块Survivor空间不足，则使用分配担保机制存入老年代
3：标记—整理 Mark—Compact
过程：所有存活的对象向一端移动，然后清除掉边界以外的内存
4：分代收集算法
过程：将堆分为新生代和老年代，根据区域特点选用不同的收集算法，如果新生代朝生夕死，则采用复制算法，老年代采用标记清除，或标记整理
面试的话说出来这四种足够了
‘叁’ java红包分配算法代码怎么用
需求得明确，是已知金钱总额 跟红包个数 提前按随机比例分配。然后有人获取红包的时候 随机给他发一个
还是 已知金额总数，红包个数 在打开红包的时候 进行一个随机比例的获取。
‘肆’ 大学java中都学过哪些经典算法请学过的朋友解答下
¤ 归并排序算法
¤ 枚举法
¤ 数字全排列问题
¤ 优化高精度减法
¤ 高精度阶乘
¤ 高精度减法
¤ 高精度乘法
¤ Dijkstra最短路径（一点到各顶点最短路径）
¤ 八皇后问题
¤ 快速排序算法
¤ 地图四色问题
¤ 穿越迷宫
¤ 常用排序算法
¤ 二分查找法完整版
¤ 标准快速排序算法
¤ 一躺快速排序法
¤ 快速排序算法
¤ 插入排序算法
¤ 选择排序算法
¤ 冒泡排序算法
¤ 统计算法
¤ 常用算法——广度优先搜索
¤ 常用算法——深度优先搜索
‘伍’ java中网络编程的服务器分配房间算法
写个简单点的服务器跟客服端就行了我写了个很简单的，只能在一个客户端跟一个服务器通信，在控制台输入下面这个是服务器import java.io.*;
import java.net.*;
import java.util.Scanner;public class Server
{
public static void main(String[] args)
{
try {
ServerSocket server=new ServerSocket(8888);//定义客户端的端口号
Socket client=server.accept();//定义一个Socket对象
InputStream is=client.getInputStream();//服务器接受信息输入流，也就是接受从服务器段发送过来的消息
BufferedReader br=new BufferedReader(new InputStreamReader(is));//用bufferedreader包装下输入流
OutputStream os=client.getOutputStream();//这是用来给服务器发送消息的输出流
PrintStream ps=new PrintStream(os);
Scanner scanner=new Scanner(System.in);//从键盘输入字符串
boolean flag=true;//定义一个死循环，让服务器不停的接受从客户端发送来的字符串
while(flag)
{
String s=br.readLine();//s是从客户端接受到得字符串
System.out.println(s);
String s2=scanner.nextLine();//s2是写给客户端的字符串
ps.println(s2); //给客户端发送你写的东西
}
client.close();
} catch (IOException e) {//try 跟catch你不用管，这是用来处理异常的，就是固定格式
e.printStackTrace();
}
}
} 下面是客户端import java.io.*;
import java.net.*;
import java.util.Scanner;public class Client
{ public static void main(String[] args)
{
try
{
Socket client=new Socket("192.168.--.--",8888);//IP地址是个字符串，端口号是个整数，这个端口号要跟前面你写的那个一样，还有IP地址，写你的机器的IP地址
InputStream is=client.getInputStream();//这边的两个流跟上面服务器的差不多的作用
BufferedReader bf=new BufferedReader(new InputStreamReader(is));
OutputStream os=client.getOutputStream();
PrintStream ps=new PrintStream(os);
Scanner scanner=new Scanner(System.in);
boolean flag=true;
while(flag)//这句话可以让客户端不停的说话
{
String s2=scanner.nextLine();
ps.println(s2);
String s=bf.readLine();
System.out.println(s); }
client.close();
}
catch (UnknownHostException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
} }}
‘陆’ 怎样用java实现CPU的调度要用到什么类
cpu调度及内存分配算法
写的一个操作系统的实验，篇幅原因，只给了内存分配和回收代码．
/**
单 位：中南大学软件学院0501班
文 件：CpuScheler.java
项 目：操作系统cpu调度算法模拟程序
作 者：刘欣
创建时间：2007年5月14日
**/
public static void InitMem(){
MemTable = new memory();
MemTable.Setmem_beg(0);
MemTable.Setmem_size(100);
MemTable.Setmem_state(0);
}
public boolean InitMemory(Pcb temp){
memory mem_temp,last,now;
last = MemTable;
mem_temp = new memory(temp.GetName(),temp.Getmem_size());
boolean flag = true;
if(mem_temp.Getmem_size() > 100 ){
c.tcpuinfo.setText(mem_temp.GetPcd_name()+"is too big");
flag = false;
}
if(MemTable == null){
return flag;
}
if(mem_temp.Getmem_size() + nowsize > 100){
c.tcpuinfo.setText("memory has been full please wait");
flag = false;
}
if(MemTable.Getmem_state() == 0){// if the first is empty;
if(MemTable.Getmem_size() > mem_temp.Getmem_size()){
mem_temp.next = MemTable;
mem_temp.Setmem_beg( last.Getmem_beg() );
mem_temp.Setmem_state(1);
MemTable.Setmem_beg(mem_temp.Getmem_beg() + mem_temp.Getmem_size());
MemTable.Setmem_size( MemTable.Getmem_size()-mem_temp.Getmem_size() );
MemTable = mem_temp;
nowsize += mem_temp.Getmem_size();
return flag;
}
if (MemTable.Getmem_size() == mem_temp.Getmem_size()){
// MemTable.SetPcd_name(mem_temp.GetPcd_name());
mem_temp = MemTable;
mem_temp.Setmem_state(1);
mem_temp.next = MemTable;
nowsize += mem_temp.Getmem_size();
return flag;
}
}
// begin obtain the other;
if(last != null){
now = last.next;
while(now != null){// search the teble for sutible memory;
if(now.Getmem_state() == 0){// if the first is empty;
if(now.Getmem_size() > mem_temp.Getmem_size()){
mem_temp.next = now;
mem_temp.Setmem_beg( now.Getmem_beg() );
mem_temp.Setmem_state(1);
now.Setmem_beg(mem_temp.Getmem_beg() + mem_temp.Getmem_size());
now.Setmem_size( now.Getmem_size()-mem_temp.Getmem_size() );
last.next = mem_temp;
nowsize += mem_temp.Getmem_size();
return flag;
}
else if (now.Getmem_size() == mem_temp.Getmem_size()){
now.SetPcd_name(mem_temp.GetPcd_name());
mem_temp = now;
mem_temp.Setmem_state(1);
last.next = mem_temp;
nowsize += mem_temp.Getmem_size();
return flag;
}
}
last = now;
//if(last != null){
now = now.next;
//}
}
}
return flag;
}
public void ReleaseMem(Pcb Temp){
memory mem_temp,last,now;
mem_temp = new memory(Temp.GetName(),Temp.Getmem_size());
if(MemTable == null){
c.tcpuinfo.setText("无内存可释放");
//return false;
}
last = MemTable;
now = last.next;
if (MemTable.GetPcd_name() == mem_temp.GetPcd_name()){//如果第一个就是要释放的分区;
MemTable.Setmem_state(0);
MemTable.SetPcd_name(null);
if(now != null && now.Getmem_state() == 0 ){//如果后邻接分区也是空闲的;
MemTable.Setmem_size(MemTable.Getmem_size() + now.Getmem_size());
MemTable.SetPcd_name(null);
nowsize -= mem_temp.Getmem_size();
MemTable.next = null;
// return true;
}
}
while (now != null){//在链表中寻找要释放的分区;
if(now.GetPcd_name() == mem_temp.GetPcd_name()){//找到;
nowsize -= mem_temp.Getmem_size();
now.Setmem_state(0);
if(now.next != null && now.next.Getmem_state() == 0){//查看后面相邻结点是否有空闲;
last.next = now.next;
now.next.Setmem_beg(now.Getmem_beg());
now.next.Setmem_size(now.Getmem_size() + now.next.Getmem_size());
now = last.next;
now.SetPcd_name(null);
}
if(last.Getmem_state() == 0){//查看前面相邻结点是否有空闲;
last.next = now.next;
last.Setmem_size(last.Getmem_size() + now.Getmem_size());
last.SetPcd_name(null);
now = last.next;
// now.SetPcd_name(null);
}
}
last = now;
now = now.next;
}
}
‘柒’ 用JAVA产生[0,1]均匀分布的随机数 要算法
double rand(double []r)
{
double base,u,p,v,temp1,temp2,temp3;
base=256.0;
u=17.0;
v=139.0;
temp1=u*(r[0])+v; //就算总数
temp2=(int)(temp1/base);//计算商
temp3=temp1-temp2*base;//余数
r[0]=temp3;//更新随机种子，为下一次使用
p=r[0]/base;//产生随机数
return p;
}
其中base为基数，一般去2的整数倍，常数，u、v可以随意取。数组r[]为只能去一个值的数组。如：double[]r={5.0}.
‘捌’ java有哪些垃圾回收算法
常用的垃圾回收算法有：
(1).引用计数算法：
给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器都为0的对象就是不再被使用的，垃圾收集器将回收该对象使用的内存。
引用计数算法实现简单，效率很高，微软的COM技术、ActionScript、Python等都使用了引用计数算法进行内存管理，但是引用计数算法对于对象之间相互循环引用问题难以解决，因此java并没有使用引用计数算法。
(2).根搜索算法：
通过一系列的名为“GC Root”的对象作为起点，从这些节点向下搜索，搜索所走过的路径称为引用链(Reference Chain)，当一个对象到GC Root没有任何引用链相连时，则该对象不可达，该对象是不可使用的，垃圾收集器将回收其所占的内存。
主流的商用程序语言C#、java和Lisp都使用根搜素算法进行内存管理。
在java语言中，可作为GC Root的对象包括以下几种对象：
a. java虚拟机栈(栈帧中的本地变量表)中的引用的对象。
b.方法区中的类静态属性引用的对象。
c.方法区中的常量引用的对象。
d.本地方法栈中JNI本地方法的引用对象。
java方法区在Sun HotSpot虚拟机中被称为永久代，很多人认为该部分的内存是不用回收的，java虚拟机规范也没有对该部分内存的垃圾收集做规定，但是方法区中的废弃常量和无用的类还是需要回收以保证永久代不会发生内存溢出。
判断废弃常量的方法：如果常量池中的某个常量没有被任何引用所引用，则该常量是废弃常量。
判断无用的类：
(1).该类的所有实例都已经被回收，即java堆中不存在该类的实例对象。
(2).加载该类的类加载器已经被回收。
(3).该类所对应的java.lang.Class对象没有任何地方被引用，无法在任何地方通过反射机制访问该类的方法。
Java中常用的垃圾收集算法：
(1).标记-清除算法：
最基础的垃圾收集算法，算法分为“标记”和“清除”两个阶段：首先标记出所有需要回收的对象，在标记完成之后统一回收掉所有被标记的对象。
标记-清除算法的缺点有两个：首先，效率问题，标记和清除效率都不高。其次，标记清除之后会产生大量的不连续的内存碎片，空间碎片太多会导致当程序需要为较大对象分配内存时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。
(2).复制算法：
将可用内存按容量分成大小相等的两块，每次只使用其中一块，当这块内存使用完了，就将还存活的对象复制到另一块内存上去，然后把使用过的内存空间一次清理掉。这样使得每次都是对其中一块内存进行回收，内存分配时不用考虑内存碎片等复杂情况，只需要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。
复制算法的缺点显而易见，可使用的内存降为原来一半。
(3).标记-整理算法：
标记-整理算法在标记-清除算法基础上做了改进，标记阶段是相同的标记出所有需要回收的对象，在标记完成之后不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，在移动过程中清理掉可回收的对象，这个过程叫做整理。
标记-整理算法相比标记-清除算法的优点是内存被整理以后不会产生大量不连续内存碎片问题。
复制算法在对象存活率高的情况下就要执行较多的复制操作，效率将会变低，而在对象存活率高的情况下使用标记-整理算法效率会大大提高。
(4).分代收集算法：
根据内存中对象的存活周期不同，将内存划分为几块，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算法 我现在有101个人 要平均分配到四个房间 每个房间的容纳人数分别为50 30 20 15.
平均分？那就是每个房间25个，可是有15和20的房间没法容纳，所以没明白你的“平均”是啥意思