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的房間沒法容納，所以沒明白你的「平均」是啥意思