2012-10-18 92 views
-11

我寫了一個程序從文件中提取信息,我需要追蹤了在這個問題上的時間和成立會議安排在同一如何在java中跟蹤管理會議管理項目的時間?

代碼:

package org.example; 

import java.io.*; 
import java.util.*; 

public class Test { 
    public static void main(String[] args) { 
     try{ 
       // Open the file that is the first command line parameter 
       FileInputStream fstream = new FileInputStream("C:\\test.txt"); 

       // Get the object of DataInputStream 
       DataInputStream in = new DataInputStream(fstream); 

       BufferedReader br = new BufferedReader(new InputStreamReader(in)); 
       String timer, strLine; 
       StringBuffer inputText = new StringBuffer(); 
       StringBuffer timeFrames = new StringBuffer(); 
       Map<String, String> mapper = new LinkedHashMap<String, String>(); 

       //Read File Line By Line 
       while ((strLine = br.readLine()) != null) { 
        inputText.append(strLine+"\n"); 
        if("lightning".equalsIgnoreCase(strLine.substring(strLine.lastIndexOf(" ")+1))){ 
         timeFrames.append("5min\n"); 
         timer = "5min"; 
        }else{ 
         timeFrames.append(strLine.substring(strLine.lastIndexOf(" ")+1)+"\n"); 
         timer = strLine.substring(strLine.lastIndexOf(" ")+1); 
        } 
        mapper.put(strLine, timer); 
       } 

       System.out.println("Input Text:"); 
       System.out.println(inputText); 

       System.out.println("Time Frames"); 
       System.out.println(timeFrames); 

       for (Map.Entry<String, String> entry : mapper.entrySet()) { 
        System.out.println(entry.getValue()+" "+entry.getKey()); 
       } 

       //Close the input stream 
       in.close(); 
       }catch (Exception e){//Catch exception if any 
       System.err.println("Error: " + e.getMessage()); 
       } 
    } 

} 

的test.txt:

Writing Fast Tests Against Enterprise Rails 60min 
Overdoing it in Python 45min 
Lua for the Masses 30min 
Ruby Errors from Mismatched Gem Versions 45min 
Common Ruby Errors 45min 
Rails for Python Developers lightning 
Communicating Over Distance 60min 
Accounting-Driven Development 45min 
Woah 30min 
Sit Down and Write 30min 
Pair Programming vs Noise 45min 
Rails Magic 60min 
Ruby on Rails: Why We Should Move On 60min 
Clojure Ate Scala (on my project) 45min 
Programming in the Boondocks of Seattle 30min 
Ruby vs. Clojure for Back-End Development 30min 
Ruby on Rails Legacy App Maintenance 60min 
A World Without HackerNews 30min 
User Interface CSS in Rails Apps 30min 

我需要執行計算並設置此項目的時間表軌道上創建一個完美的會議。

會議開始於09:00AN - 01-00;午餐時間 - 01:00 - 02:00,下半年是從02:00 -05:00

任何想法提前十分讚賞和感謝

乾杯!

+0

http://www.iopus.com/guides/winscheduler.htm這樣的事情? – Ved

+0

@藍我說的是java和編程方法,它不適用於Windows任務調度程序 – GOK

+9

如果您從ThoughtWorks面試問題中複製了此內容,我想要求您把它記下來。這個問題是真誠地發給你的,你不會在互聯網上公佈它。我們現在正在被複制貓淹沒。 –

回答

1

好吧,我要採取算法的方法來回答你的問題。它看起來像經典的Bin Packing algorithm,它是那裏的NP-hard算法之一。

如果這是您嘗試解決的實際問題,有一件事您可能想要優化。

確保您有足夠的時間來處理您的會議,包括休息和午餐。例如,如果您有1小時內需要的內容需要10小時 ,而在1小時內需要2小時的 休息時間,您希望此程序快速失敗,並告訴您需要添加更多曲目以便分開會談。當然,如果你是 分裂軌道,你可能想添加一塊 數據,以保持同一軌道上的類似會談。同樣,如果這是一個真正的問題,你的清單可以幫助你,否則可能需要一些更復雜的技術。

好的,在你弄明白之後,你會知道問題是可以解決的。如果你不這樣做,那麼你會浪費你的時間和處理器時間。

然後,如果數量很小,您可以使用蠻力算法來查找所有可能的組合,這些組合適合指定的時間,這對於一次性實際生活問題的開發人員而言可能是實用的,因爲談話的數量N很小。但是,如果你的問題更具學術性,那麼你將需要應用啓發式。

+1

不錯的一個好友,但要實現它,我可以有一些提示或一些實時示例或源代碼的參考... – GOK

+0

這是一個學術問題還是一個真正的問題?還有什麼問題的大小?這些都是實施解決方案的因素。然而,強力解決方案的一個非常好的改進是Backtracking算法(http://en.wikipedia.org/wiki/Backtracking)。一旦你理解了這個概念,你應該能夠實現它。有很多很多的例子和算法書籍可以解釋解決這個問題的算法。 – KappaMax

0

這裏是你的問題的解決方案,希望這將幫助你

public List<TrackInfo> readFile(BufferedReader reader) throws IOException { 
    TrackInfo trackInfo=null; 
    List<TrackInfo> trackList = new ArrayList<TrackInfo>(); 
    String line; 
    while((line = reader.readLine())!= null){ 
     trackInfo = new TrackInfo(); 
     if("lightning".equalsIgnoreCase(line.substring(line.lastIndexOf(" ")+1))){ 
      trackInfo.setEventTime("5min"); 
     }else{ 
      trackInfo.setEventTime(line.substring(line.lastIndexOf(" ")+1)); 
     } 
     trackInfo.setEventDesc(line.substring(0, line.lastIndexOf(" "))); 
     trackList.add(trackInfo); 
    } 

    return trackList; 
} 

@SuppressWarnings("deprecation") 
@Override 
public Map<String, List<String>> processEventTime(List<TrackInfo> trackInfo) { 
    Calendar cal = new GregorianCalendar(); 
    SimpleDateFormat sdf = new SimpleDateFormat(SIMPLE_DATE_FORMAT); 
    cal.set(Calendar.HOUR_OF_DAY, HOUR_OF_DAY); 
    cal.set(Calendar.MINUTE, MIN); 
    String startTime; 
    String finishTime; 
    int track =1; 
    List<String> eventTime = new ArrayList<String>(); 
    Map<String, List<String>> confRoomData = new HashMap<String, List<String>>(); 
    for(TrackInfo trackData: trackInfo){ 
     startTime = sdf.format(cal.getTime()); 
     finishTime = getFormattedTime(trackData.getEventTime(), cal, sdf); 
     String flag = getTimeDiff(startTime, finishTime); 
     if(LUNCH_TIME.equals(flag)){ 
      eventTime.add(flag+": LUNCH"); 
      int minute = Integer.valueOf(trackData.getEventTime().replaceAll("min", "")); 
      cal.add(Calendar.MINUTE, -cal.getTime().getMinutes()); 
      cal.add(Calendar.MINUTE, 60); 
      eventTime.add(sdf.format(cal.getTime())+": "+trackData.getEventDesc()); 
      cal.add(Calendar.MINUTE, minute); 
     }else if(END_OF_DAY.equals(flag)){ 
      eventTime.add(flag+": Networking Event"); 
      cal.set(Calendar.HOUR_OF_DAY, HOUR_OF_DAY); 
      cal.set(Calendar.MINUTE, MIN); 
      confRoomData.put(("track_"+track), eventTime); 
      eventTime = new ArrayList<String>(); 
      eventTime.add(sdf.format(cal.getTime())+": "+trackData.getEventDesc()); 
      finishTime = getFormattedTime(trackData.getEventTime(), cal, sdf); 
      ++track; 
     }else{ 
      eventTime.add(startTime+": "+trackData.getEventDesc()); 
     } 
    } 
    confRoomData.put(("track_"+track), eventTime); 
    return confRoomData; 
} 

/* 
* This method calculating time difference for Lunch time (12:00 pm) & end of day i.e. 05:00pm 
* @input 'startEventTime' and 'finishEventTime' 
* @return time difference as String 
*/ 
private String getTimeDiff(String startEventTime, String finishEventTime) { 
    DateFormat df = new SimpleDateFormat("h:mma"); 
    try { 
     Date startTime = (Date) df.parse(startEventTime); 
     Date finishTime = (Date) df.parse(finishEventTime); 
     Date lunchTime = (Date) df.parse(LUNCH_TIME); 
     Date endOfDay = (Date) df.parse(END_OF_DAY); 
     if(finishTime.compareTo(lunchTime) == 0 && startTime.compareTo(lunchTime) > 0){ 
      return LUNCH_TIME; 
     } else if(startTime.compareTo(lunchTime) == 0 && finishTime.compareTo(lunchTime) > 0){ 
      return LUNCH_TIME; 
     } else if(startTime.compareTo(lunchTime) < 0 && finishTime.compareTo(lunchTime) > 0){ 
      return LUNCH_TIME; 
     } 
     if(endOfDay.compareTo(finishTime)<0){ 
      return END_OF_DAY; 
     } 
    } catch (ParseException e) { 
     e.printStackTrace(); 
    } 
    return ""; 
} 

private String getFormattedTime(String eventTime, Calendar cal, SimpleDateFormat sdf) { 
    if(null != eventTime && !"".equals(eventTime)){ 
     eventTime = eventTime.replaceAll("min", ""); 
    } 
    cal.add(Calendar.MINUTE, Integer.valueOf(eventTime)); 

    return sdf.format(cal.getTime()); 
} 
+0

@ryadavilli主要方法如何查找上述程序。請您編輯並提供信息 –

+0

,主程序如何查找上述程序。請您在Java註釋中編輯和提供信息以便於理解。 –

1

所以,以下是我對ConferenceTrackManagement程序代碼。我保持GUI代碼遠離邏輯。他們都在不同的班級。我的程序所做的唯一假設是,您提供了一些適當的輸入,可以按照提供的規則將其隔離到正確的軌道中。

import java.awt.BorderLayout; 
import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 

import javax.swing.JButton; 
import javax.swing.JFrame; 
import javax.swing.JLabel; 
import javax.swing.JPanel; 
import javax.swing.JScrollPane; 
import javax.swing.JTextArea; 
import javax.swing.SwingUtilities; 
import javax.swing.border.EmptyBorder; 

public abstract class CommonInterface { 
    protected CommonInterface(final String title) { 
     SwingUtilities.invokeLater(new Runnable() { 
      @Override 
      public void run() { 
       makeGUI(title); 
       showGUI(); 
      } 
     }); 
    } 

    protected JFrame frame; 
    protected JTextArea textArea; 
    protected JButton button; 
    protected JLabel label; 

    protected String originalInputText, inputText, outputText = ""; 

    protected void makeGUI(final String title) { 
     frame = new JFrame(title + " : By Aman Agnihotri"); 
     textArea = new JTextArea(30, 40); 
     button = new JButton("Compute"); 
     label = new JLabel("Test Input:"); 

     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

     JPanel panel = new JPanel(); 
     panel.setLayout(new BorderLayout()); 
     panel.setBorder(new EmptyBorder(5, 5, 2, 5)); 
     panel.add(label, BorderLayout.WEST); 
     panel.add(button, BorderLayout.EAST); 

     JScrollPane scrollPane = new JScrollPane(textArea); 
     scrollPane.setBorder(new EmptyBorder(2, 5, 5, 5)); 

     frame.add(panel, BorderLayout.NORTH); 
     frame.add(scrollPane, BorderLayout.CENTER); 

     frame.pack(); 
     frame.setMinimumSize(frame.getSize()); 
     frame.setLocationRelativeTo(null); 

     button.addActionListener(new ActionListener() { 
      @Override 
      public void actionPerformed(ActionEvent e) { 
       if (button.getText().equals("Compute")) { 
        refresh(); 
        computeOutput(); 
        button.setText("Back"); 
        label.setText("Test Output:"); 
        textArea.setText(outputText); 
       } else { 
        button.setText("Compute"); 
        label.setText("Test Input:"); 
        textArea.setText(originalInputText); 
       } 
      } 
     }); 
    } 

    protected abstract void refresh(); 

    protected abstract void computeOutput(); 

    protected void showGUI() { 
     frame.setVisible(true); 
    } 
} 

public class ConferenceTrackManagement extends CommonInterface { 

private String[] eventArray; 
private int[] timeArray; 

private boolean isOutputInvalid; 

private final int MAX_TRACK_TIME = 420; // 1 Track Max Time = 420 minutes. 

public ConferenceTrackManagement() { 
    super("Conference Track Management"); 
} 

@Override 
protected void refresh() { 
    isOutputInvalid = false; 
    outputText = ""; 
} 

@Override 
protected void computeOutput() { 
    originalInputText = textArea.getText(); 
    inputText = originalInputText; 

    computeEventAndTimeArray(); 

    if (!isOutputInvalid) { 
     computeTracks(); 
    } 
} 

private int startIndex = -1, endIndex = -1, time; 

private void computeTracks() { 
    int totalTime = getTotalTime(); 
    int requiredTracks = totalTime/MAX_TRACK_TIME + 1; 
    sortEventAndTimeArray(); 

    for (int i = 1; i <= requiredTracks; i++) { 
     boolean found = exactSubArraySum(timeArray, 180); // morning time 

     if (found) { 
      time = 9 * 60; // starts at 9 am [9 * 60 is in minutes] 
      outputText += "Track " + i + ":\n\n"; 
      for (int j = startIndex; j <= endIndex; j++) { 
       outputText += timeStamp(time, "AM") + " " + eventArray[j] 
         + "\n"; 
       time += timeArray[j]; 
      } 

      deleteProperElements(); 
      outputText += "12:00PM Lunch\n"; 

      boolean relativeFound = relativeSubArraySum(timeArray, 180, 240); 

      if (relativeFound) { 
       time = 60; // starts at 1 pm [1 * 60 is in minutes] 
       outputText += "\n"; 
       for (int j = startIndex; j <= endIndex; j++) { 
        outputText += timeStamp(time, "PM") + " " 
          + eventArray[j] + "\n"; 
        time += timeArray[j]; 
       } 

       deleteProperElements(); 
       outputText += timeStamp(time, "PM") + " Networking Event" 
         + "\n"; 
       outputText += "\n\n"; 
      } 
     } else 
      outputText = "No proper solution found."; 
    } 
} 

private String timeStamp(int time, String mode) { 
    String timeStamp = ""; 

    int hours = time/60; 
    int minutes = time % 60; 

    String hourHint = "", minuteHint = ""; 
    if (hours < 10) 
     hourHint = "0"; 
    if (minutes < 10) 
     minuteHint = "0"; 
    timeStamp = hourHint + hours + ":" + minuteHint + minutes + mode; 

    return timeStamp; 
} 

private void deleteProperElements() { 
    String[] tempEventArray = new String[eventArray.length 
      - (endIndex - startIndex) - 1]; 
    int[] tempTimeArray = new int[tempEventArray.length]; 

    int index = 0; 
    for (int j = 0; j < startIndex; j++) { 
     tempEventArray[index] = eventArray[j]; 
     tempTimeArray[index] = timeArray[j]; 
     index++; 
    } 
    for (int j = endIndex + 1; j < eventArray.length; j++) { 
     tempEventArray[index] = eventArray[j]; 
     tempTimeArray[index] = timeArray[j]; 
     index++; 
    } 

    timeArray = tempTimeArray; 
    eventArray = tempEventArray; 
} 

private boolean exactSubArraySum(int array[], int sum) { 
    if (!(array.length >= 1)) 
     return false; 
    int currentSum = array[0], start = 0; 

    for (int i = 1; i <= array.length; i++) { 
     while (currentSum > sum && start < i - 1) { 
      currentSum -= array[start]; 
      start++; 
     } 

     if (currentSum == sum) { 
      startIndex = start; 
      endIndex = i - 1; 
      return true; 
     } 

     if (i < array.length) 
      currentSum += array[i]; 
    } 

    return false; // No sub array found. 
} 

private boolean relativeSubArraySum(int array[], int minimumSum, 
     int maximumSum) { 
    if (!(array.length >= 1)) 
     return false; 
    int currentSum = array[0], start = 0; 

    for (int i = 1; i <= array.length; i++) { 
     while (currentSum > maximumSum && start < i - 1) { 
      currentSum -= array[start]; 
      start++; 
     } 

     if (currentSum >= minimumSum && currentSum <= maximumSum) { 
      startIndex = start; 
      endIndex = i - 1; 
      return true; 
     } 

     if (i < array.length) 
      currentSum += array[i]; 
    } 

    return false; // No sub array found. 
} 

private void sortEventAndTimeArray() { 
    for (int i = 1; i < timeArray.length; i++) { 
     for (int j = 0; j < timeArray.length - i; j++) { 
      if (timeArray[j] > timeArray[j + 1]) { 
       int tempTime = timeArray[j]; 
       timeArray[j] = timeArray[j + 1]; 
       timeArray[j + 1] = tempTime; 

       String tempEvent = eventArray[j]; 
       eventArray[j] = eventArray[j + 1]; 
       eventArray[j + 1] = tempEvent; 
      } 
     } 
    } 
} 

private int getTotalTime() { 
    int timeSum = 0; 
    for (int i = 0; i < timeArray.length; i++) 
     timeSum += timeArray[i]; 
    return timeSum; 
} 

private void computeEventAndTimeArray() { 
    String lines[] = inputText.split("[\\r\\n]+"); 

    eventArray = new String[lines.length]; 
    timeArray = new int[lines.length]; 

    for (int i = 0; i < lines.length; i++) { 
     String line = lines[i]; 
     line = line.trim(); 

     int lastIndexOfSpace = line.lastIndexOf(' '); 

     eventArray[i] = line.substring(0, lastIndexOfSpace); 
     String currentTime = line.substring(lastIndexOfSpace + 1); 

     currentTime = currentTime.toLowerCase(); 
     if (currentTime.endsWith("lightning")) 
      setEventAndTimeFor(i, currentTime, "lightning", 5); 
     else if (currentTime.endsWith("min")) 
      setEventAndTimeFor(i, currentTime, "min", 1); 
     else { 
      setOutputAsInvalid(i); 
     } 
    } 
} 

private void setEventAndTimeFor(int i, String currentTime, String type, 
     int scale) { 
    String timeValue = currentTime.substring(0, currentTime.indexOf(type)); 

    if (timeValue.equals("")) 
     timeArray[i] = scale; 
    else { 
     try { 
      timeArray[i] = Integer.parseInt(timeValue) * scale; 
     } catch (Exception e) { 
      setOutputAsInvalid(i); 
     } 
    } 
} 

private void setOutputAsInvalid(int lineNumber) { 
    outputText += "Invalid Time Entry in line " + (lineNumber + 1) + "\n"; 
    isOutputInvalid = true; 
} 

public static void main(String args[]) { 
    new ConferenceTrackManagement(); 
} 
} 
+0

你遵循什麼樣的方法? 回溯或別的東西。 – ved

+0

我在這個項目中基本上做的是,首先我會理清每個事件的不同時間。然後,我嘗試將它們放入時間間隔爲180分鐘(早上9至12天)和時間間隔爲180至240分鐘的「垃圾箱」中(下午的會議時間爲1至4小時,可用1小時如果事件不適合)。我稱這些箱子子陣爲它們從時間陣列本身形成的。其種類包裝算法。 –

+4

迴應Sudhir的上述評論:如果您在** ThoughtWorks **的招聘過程中尋找簡單的方式來回應編碼問題,請不要寄給我們一份副本。我們知道許多已發佈的解決方案,這對所有相關人員來說都是浪費時間。 –

1
package conference.time.management.main; 

import java.io.BufferedReader; 
import java.io.DataInputStream; 
import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.InputStreamReader; 
import java.text.SimpleDateFormat; 
import java.util.ArrayList; 
import java.util.Date; 
import java.util.Iterator; 
import java.util.List; 
import java.util.concurrent.CopyOnWriteArrayList; 

import conference.time.management.exceptions.InvalidTalkException; 

public class ConferenceTimeManager { 

    public static void main(String[] args) { 

     String fileName = "D:\\Java_Softwares\\new-softwares\\CTM.txt"; 
     ConferenceTimeManager conferenceTimeManager = new ConferenceTimeManager(); 
     try { 
      List<String> talkList = conferenceTimeManager 
        .getTalkListFromFile(fileName); 
      CopyOnWriteArrayList<String> talksWith60MinDuration = new CopyOnWriteArrayList<String>(); 
      CopyOnWriteArrayList<String> talksWith45MinDuration = new CopyOnWriteArrayList<String>(); 
      CopyOnWriteArrayList<String> talksWith30MinDuration = new CopyOnWriteArrayList<String>(); 

      List<String> talksWithlightning = new ArrayList<String>(); 
      for (String talk : talkList) { 
       if (talk.endsWith("60min")) { 
        talksWith60MinDuration.add(talk); 
       } else if (talk.endsWith("45min")) { 
        talksWith45MinDuration.add(talk); 
       } else if (talk.endsWith("30min")) { 
        talksWith30MinDuration.add(talk); 
       } else if (talk.endsWith("lightning")) { 
        talksWithlightning.add(talk); 
       } else { 
        throw new InvalidTalkException("Talk may not scheduled"); 
       } 

      } 

      talksWith30MinDuration.addAll(talksWithlightning); 

      CopyOnWriteArrayList<String> sortedtalkList = new CopyOnWriteArrayList<String>(); 

      sortedtalkList.addAll(talksWith60MinDuration); 
      sortedtalkList.addAll(talksWith45MinDuration); 
      sortedtalkList.addAll(talksWith30MinDuration); 

      /* 
      * for (String string : sortedtalkList) { 
      * 
      * System.out.println(string); } 
      */ 

      doNewTracking(sortedtalkList); 

      /* 
      * System.out.println(
      * "#####################################################################################" 
      *); List<String> unScheduled60MinTalks = 
      * prepareFirstDayMorningSessionWith180Min(talksWith60MinDuration); 
      * System.out.println(
      * "****************************************************************" 
      *); List<String> unScheduled45MinTalks = 
      * prepareSecondDayMorningSessionWith180Min(talksWith45MinDuration); 
      * System.out.println(
      * "****************************************************************" 
      *); CopyOnWriteArrayList<String> unScheduledTalks = new 
      * CopyOnWriteArrayList<String>(); 
      * unScheduledTalks.addAll(unScheduled45MinTalks); 
      * unScheduledTalks.addAll(unScheduled60MinTalks); 
      * 
      * List<String> unScheduledMiscTalks = 
      * prepareFirstDayAfternoonSessionWith210Min(unScheduledTalks); 
      * System.out.println(
      * "****************************************************************************" 
      *); 
      * prepareSecondDayAfternoonSessionWith215Min(talksWith30MinDuration 
      *); 
      * 
      * System.out.println(
      * "------------------------------------------------------------------------" 
      *); for (String unScheduledMiscTalk : unScheduledMiscTalks) { 
      * System.out.println(unScheduledMiscTalk); } 
      */ 

     } catch (InvalidTalkException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
    } 

    private static void doNewTracking(
      CopyOnWriteArrayList<String> sortedtalkList) { 

     int firstDayMorningSession = 180; 
     int firstDayAfternoonSession = 210; 
     int secondDayMorningSession = 180; 
     int secondDayAfternoonSession = 215; 

     List<Integer> sessionList = new ArrayList<Integer>(); 
     sessionList.add(firstDayMorningSession); 
     sessionList.add(firstDayAfternoonSession); 
     sessionList.add(secondDayMorningSession); 
     sessionList.add(secondDayAfternoonSession); 

     for (Integer session : sessionList) { 

      arrangeConf(sortedtalkList, session); 
     } 

    } 

    private static void arrangeConf(
      CopyOnWriteArrayList<String> sortedtalkList, int maxLimit) { 

     Date date = new Date(0); 
     SimpleDateFormat simpleDateFormat = new SimpleDateFormat("hh:mma"); 

     date.setHours(9); 
     date.setMinutes(0); 
     date.setSeconds(0); 
     Iterator<String> iterator = sortedtalkList.listIterator(); 
     String timString = null; 
     String talk = null; 
     Date lunchdate = new Date(0); 
     SimpleDateFormat dateFormat = new SimpleDateFormat("hh:mma"); 
     lunchdate.setHours(12); 
     lunchdate.setMinutes(0); 
     lunchdate.setSeconds(0); 
     String dateLunch = dateFormat.format(lunchdate); 
     SimpleDateFormat dateFormat3 = null; 
     Date afterlunchdate = null; 
     int totalTime = 0; 
     while (iterator.hasNext()) { 
      talk = iterator.next(); 
      if (totalTime > 450) { 
       date.setHours(9); 
       date.setMinutes(0); 
       date.setSeconds(0); 
       totalTime = 0; 
      } 
      timString = simpleDateFormat.format(date); 
      if (timString.equalsIgnoreCase(dateLunch)) { 
       System.out.println(dateLunch + ":" + "Lunch"); 
       afterlunchdate = new Date(0); 
       dateFormat3 = new SimpleDateFormat("hh:mma"); 
       afterlunchdate.setHours(13); 
       afterlunchdate.setMinutes(0); 
       afterlunchdate.setSeconds(0); 
       String afterdateLunch = dateFormat3.format(afterlunchdate); 
       timString = afterdateLunch; 
       System.out.println(timString); 
      } else { 
       if (totalTime > 180 && totalTime < 240) { 
        afterlunchdate = new Date(0); 
        dateFormat3 = new SimpleDateFormat("hh:mma"); 
        afterlunchdate.setHours(13); 
        afterlunchdate.setMinutes(0); 
        afterlunchdate.setSeconds(0); 
        String afterdateLunch = dateFormat3.format(afterlunchdate); 
        timString = afterdateLunch; 
        // System.out.println(timString+": "+talk); 
       } 
       System.out.println(timString + ": " + talk); 
       sortedtalkList.remove(talk); 
      } 

      if (talk.endsWith("60min")) { 
       totalTime = totalTime + 60; 
       date.setHours(date.getHours() + 1); 
      } else if (talk.endsWith("45min")) { 
       totalTime = totalTime + 45; 
       date.setMinutes(date.getMinutes() + 45); 
      } else if (talk.endsWith("30min")) { 
       totalTime = totalTime + 30; 
       date.setMinutes(date.getMinutes() + 30); 
      } 
     } 

     // System.out.println(timString); 

    } 

    private static void prepareSecondDayAfternoonSessionWith215Min(
      CopyOnWriteArrayList<String> talksWith30MinDuration) { 

     int totalTimeForThisSession = 215; 
     int timeOccupied = 0; 
     Iterator<String> iterator = talksWith30MinDuration.iterator(); 

     while (iterator.hasNext()) { 
      String talk = iterator.next(); 
      int timeToRemove = 0; 
      if (timeOccupied < 215) { 
       if (talk.endsWith("30min")) { 
        timeToRemove = 30; 
       } else { 
        timeToRemove = 5; 
       } 
       System.out.println("talk 4 : " + talk); 
       talksWith30MinDuration.remove(talk); 
       timeOccupied = timeOccupied + timeToRemove; 
      } 
     } 

    } 

    private static List<String> prepareFirstDayAfternoonSessionWith210Min(
      CopyOnWriteArrayList<String> unScheduledTalks) { 

     int totalTimeForThisSession = 200; 
     int timeOccupied = 0; 
     Iterator<String> iterator = unScheduledTalks.iterator(); 

     while (iterator.hasNext()) { 
      String talk = iterator.next(); 
      int timeToRemove = 0; 
      if (timeOccupied < 200) { 
       if (talk.endsWith("60min")) { 
        timeToRemove = 60; 
       } else if (talk.endsWith("45min")) { 
        timeToRemove = 45; 
       } else if (talk.endsWith("30min")) { 
        timeToRemove = 30; 
       } 
       System.out.println("talk 2 : " + talk); 
       unScheduledTalks.remove(talk); 
       timeOccupied = timeOccupied + timeToRemove; 
      } 
     } 

     return unScheduledTalks; 
    } 

    private static List<String> prepareSecondDayMorningSessionWith180Min(
      CopyOnWriteArrayList<String> talksWith45MinDuration) { 
     int totalTimeForThisSession = 180; 
     int timeOccupied = 0; 
     Iterator<String> iterator = talksWith45MinDuration.iterator(); 

     while (iterator.hasNext()) { 
      String talk = iterator.next(); 
      if (timeOccupied < 180 && talk.endsWith("45min")) { 
       System.out.println("talk 3 : " + talk); 
       talksWith45MinDuration.remove(talk); 
       timeOccupied = timeOccupied + 45; 
      } 
     } 

     return talksWith45MinDuration; 
    } 

    @SuppressWarnings("deprecation") 
    private static List<String> prepareFirstDayMorningSessionWith180Min(
      CopyOnWriteArrayList<String> talksWith60MinDuration) { 

     int totalTimeForThisSession = 180; 
     int timeOccupied = 0; 
     Iterator<String> iterator = talksWith60MinDuration.iterator(); 

     while (iterator.hasNext()) { 
      String talk = iterator.next(); 
      if (timeOccupied < 180 && talk.endsWith("60min")) { 

       /* 
       * Date date = new Date(); SimpleDateFormat dateFormat = new 
       * SimpleDateFormat ("hh:mma"); date.setHours(9); 
       * date.setMinutes(0); date.setSeconds(0); 
       * 
       * String scheduledTime = dateFormat.format(date); 
       */ 
       System.out.println(/* 
            * scheduledTime.getHours()+scheduledTime. 
            * getSeconds()+ 
            */"talk 1 : " + talk); 
       talksWith60MinDuration.remove(talk); 
       timeOccupied = timeOccupied + 60; 
      } 
     } 

     return talksWith60MinDuration; 
    } 

    public List<String> getTalkListFromFile(String fileName) 
      throws InvalidTalkException { 
     List<String> talkList = new ArrayList<String>(); 
     try { 
      FileInputStream fstream = new FileInputStream(fileName); 
      DataInputStream in = new DataInputStream(fstream); 
      BufferedReader br = new BufferedReader(new InputStreamReader(in)); 
      String strLine = br.readLine(); 
      while (strLine != null) { 
       talkList.add(strLine); 
       strLine = br.readLine(); 
      } 
      in.close(); 
     } catch (Exception e) { 
      System.err.println("Error: " + e.getMessage()); 
     } 

     return talkList; 
    } 

} 
+0

對代碼進行某種描述以及如何回答問題總是很好的。你面臨的挑戰是什麼?請[編輯]你的答案包括這個。 –

+0

什麼是CopyOnWriteArrayList? – adityawho