- 1
 - 2
 - 3
 - 4
 - 5
 
public void restore(HashMap<String, Object> dump) {
		if(dump != null) {
			if(isInitialized()) {
				if(isInitialized()) {
					clear();
                                    Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+79
public void restore(HashMap<String, Object> dump) {
		if(dump != null) {
			if(isInitialized()) {
				if(isInitialized()) {
					clear();
                                    "Проинициализировано? Точно-точно?"
+79
ArrayList<String> Stack = new ArrayList<String>(14);
 ArrayList<String> ShuffledStack = new ArrayList<String>(14); 
 
Stack.add(0,"a");
Stack.add(1,"b");
Stack.add(2,"c");
Stack.add(3,"d");
Stack.add(4,"e");
Stack.add(5,"f"); 
Stack.add(6,"e");
Stack.add(7,"g");
Stack.add(8,"h");
Stack.add(9,"j");
Stack.add(10,"k");
Stack.add(11,"l");
Stack.add(12,"o");
Stack.add(13,"m"); 
 
int size = Stack.size(); 
 
while(ShuffledStack.size() != size)
         {
             int r = (int)(Math.random()*(size));
                   if(!ShuffledStack.contains( Stack.get( r   )))
                       ShuffledStack.add( Stack.get( r   )); 
 
         }
                                    
            > Еще более гнетет то что великого старину Доналда Кнута я так и не прочел. Дело в том что там большинство алгоритмов на математических формулах и основаны(бля, меня колбасит от такого)))...
Источник: http://pyha.ru/forum/topic/3831.0
        
+79
/**
 * @return
 * true - если все строчки выделены,
 * false - если все строчки не выделены,
 * null - если есть как выделенные, так и не выделенные строчки
 */
private Boolean lookRowsDownwards(ColumnHolder rowHolder, boolean isPreviousRowsSelected) {
                                    это реализация переключателя с 3-мя состояниями
+79
boolean direct = !Boolean.FALSE.equals(directParam);
    boolean demoAgency = !direct;
                                    
+79
private double findVar(String vname) throws InterpreterException {
    if (!Character.isLetter(vname.charAt(0))) {
        handleErr(SYNTAX);
        return 0.0;	// ?!
    }
    return vars[Character.toUpperCase(vname.charAt(0))-'A'];
}
                                    
+79
public boolean ComparePassword(String userName, String ComparablePassword) throws SQLException
    {
        try{
        if(c == null) Connect();
        /*PreparedStatement stmt = c.prepareStatement("SELECT * FROM users WHERE name = ?");*/
        PreparedStatement stmt = c.prepareStatement("SELECT 1 FROM users WHERE name = ? AND password = ?");
	stmt.setString(1, userName);
        stmt.setString(2, ComparablePassword);
        ResultSet rs = stmt.executeQuery();
        /*String a = rs.getString(3);
        if(ComparablePassword.compareTo(a) == 0) //бл**ь, ну почему в этой *** джаве это не работает? придется как обычно делать через *опу:(
            return true;
        else
        {
            return false;
        }
        */
        if(!rs.next())
            return false;
        else return true;
        }
        catch(SQLException e)
        {
            return false;
        }
    }
                                    Найдено в недрах исходников одного сайта на Java :)
+79
Object sync;
try {
    synchronized (sync){
        sync.wait();
    }
} catch (NullPointerException npe){
    sync = new Object();
    synchronized (sync){
        sync.wait();
    }
}
                                    Вот так чел пытался избежать "ненужного" создания объекта-монитора. Память экономил...
+79
private double MLn(double x0){
    double x=x0;
    double y=0;
        //Получаем показатель степени.
        String s0=""+x;
        int i=s0.indexOf("E");
        String s1=s0.substring(i+1, s0.length());//Правее E 
        String s2=s0.substring(0, i);//Левее E
        double a=0,b=0; 
        a=Double.parseDouble(s1)+1;
        b=Double.parseDouble(s2)/10; 
  //Вычисление Логарифма b как суммы ряда Тейлора
       int n=1;
       double sn=1;
       while (sn>(1E-16)*n){
          sn=-sn*(b-1);
          y=y+sn/n;
          n=n++;
      }
    y=y+a*2.302585092994046;
    return y;
}
                                    нашел на одном сайте как на j2me можно вычислить логарифм.
+79
String [] itemmas = item.split("~");
String start = "";
String end = "";
String task = "";
String project = "";
String wtype = "";
String desc = "";
try{
   start = itemmas[0];
}catch (Exception e){}
try{
   end = itemmas[1];
}catch (Exception e){}
try{
   task = itemmas[2];
}catch (Exception e){}
try{
   project = itemmas[3];
}catch (Exception e){}
try{
   wtype = itemmas[4];
}catch (Exception e){}
try{
   desc = itemmas[5];
}catch (Exception e){}
if(start==null||start.equals("null")){start="";};
if(end==null||end.equals("null")){end="";};
if(task==null||task.equals("null")){task="";};
if(project==null||project.equals("null")){project="";};
if(wtype==null||wtype.equals("null")){wtype="";};
if(desc==null||desc.equals("null")){desc="";};
                                    
+79
public class LessOperator extends GreaterOperator {
    public Object evaluateNode(ITreeNode node, List<NodeValuePair> list) throws CalculatorException {
        return !(Boolean)super.evaluateNode(node, list);
    }
}
                                    
            Видимо тут программист решил сократить себе работу и реализовал оператор сравнения "меньше" как "не больше", использовав готовую реализацию оператора "больше".
В результате вместо операции "меньше" получили операцию "меньше или равно".