Скрытые возможности Java

голоса
295

После прочтения скрытых Особенности C # я задавался вопросом , Что некоторые из скрытых особенностей Java?

Задан 19/08/2008 в 02:36
источник пользователем
На других языках...                            


100 ответов

голоса
432

Дважды Brace инициализации взял меня врасплох несколько месяцев назад , когда я впервые обнаружил , что это, никогда не слышал об этом раньше.

ThreadLocals , как правило , не столь широко известен как способ хранения каждого потока состояния.

Поскольку JDK 1.5 Java была очень хорошо реализован и надежные инструменты параллелизм за пределы только замки, они живут в java.util.concurrent и специально интересным примером является java.util.concurrent.atomic подпакет , который содержит поточно-примитивов , которые Реализовать сравнить и-своп операции и может отображаться на реальных родных аппаратных поддерживаемых версий этих операций.

Ответил 19/08/2008 в 21:09
источник пользователем

голоса
279

Совместное объединение в дисперсии параметра типа:

public class Baz<T extends Foo & Bar> {}

Например, если вы хотите принять параметр, это и Сопоставимые и коллекции:

public static <A, B extends Collection<A> & Comparable<B>>
boolean foo(B b1, B b2, A a) {
   return (b1.compareTo(b2) == 0) || b1.contains(a) || b2.contains(a);
}

Это надуманный метод возвращает истину, если две указанные коллекции равны или, если ни одна из них содержит данный элемент, иначе ложь. Дело в том, чтобы заметить, что вы можете вызывать методы как Сопоставимые и сбора на аргументы b1 и b2.

Ответил 03/09/2008 в 22:51
источник пользователем

голоса
220

Я был удивлен экземпляром инициализаторах другой день. Я удаление некоторых кодовые сложенные методов и в конечном итоге создание нескольких инициализаторов экземпляра:

public class App {
    public App(String name) { System.out.println(name + "'s constructor called"); }

    static { System.out.println("static initializer called"); }

    { System.out.println("instance initializer called"); }

    static { System.out.println("static initializer2 called"); }

    { System.out.println("instance initializer2 called"); }

    public static void main( String[] args ) {
        new App("one");
        new App("two");
  }
}

Выполнение mainметода будет отображать:

static initializer called
static initializer2 called
instance initializer called
instance initializer2 called
one's constructor called
instance initializer called
instance initializer2 called
two's constructor called

Я думаю, это было бы полезно, если у вас несколько конструкторов и нужен общий код

Они также обеспечивают синтаксический сахар для инициализации классы:

List<Integer> numbers = new ArrayList<Integer>(){{ add(1); add(2); }};

Map<String,String> codes = new HashMap<String,String>(){{ 
  put("1","one"); 
  put("2","two");
}};
Ответил 06/09/2008 в 15:27
источник пользователем

голоса
201

JDK 1.6_07 + содержит приложение под названием VisualVM (бен / jvisualvm.exe), что является хорошим графическим интерфейсом на вершине многих инструментов. Это кажется более полным, чем JConsole.

Ответил 11/09/2008 в 02:15
источник пользователем

голоса
173

Путь к классам джокеров, так как Java 6.

java -classpath ./lib/* so.Main

Вместо

java -classpath ./lib/log4j.jar:./lib/commons-codec.jar:./lib/commons-httpclient.jar:./lib/commons-collections.jar:./lib/myApp.jar so.Main

См http://java.sun.com/javase/6/docs/technotes/tools/windows/classpath.html

Ответил 07/12/2009 в 12:59
источник пользователем

голоса
156

Для большинства людей, я интервью позиции разработчиков Java меченых блоки очень удивительно. Вот пример:

// code goes here

getmeout:{
    for (int i = 0; i < N; ++i) {
        for (int j = i; j < N; ++j) {
            for (int k = j; k < N; ++k) {
                //do something here
                break getmeout;
            }
        }
    }
}

Кто сказал , что gotoв Java это просто ключевое слово? :)

Ответил 02/09/2008 в 13:57
источник пользователем

голоса
144

Как насчет ковариантных типов возврата , которые были на месте , так как JDK 1.5? Это довольно плохо огласку, так как это unsexy дополнение, но , как я понимаю, является абсолютно необходимым для дженериков работать.

По существу, компилятор позволяет теперь подклассу сужать тип возвращаемого перекрытого метода быть подклассом типа возвращаемого значения оригинального метода. Так что это допускается:

class Souper {
    Collection<String> values() {
        ...
    }
}

class ThreadSafeSortedSub extends Souper {
    @Override
    ConcurrentSkipListSet<String> values() {
        ...
    }
}

Вы можете вызвать подкласс valuesметод и получить отсортированный Потокобезопасные Setиз Stringй без вниз броска к ConcurrentSkipListSet.

Ответил 29/08/2008 в 20:29
источник пользователем

голоса
142

Не видел, чтобы кто упомянуть InstanceOf осуществляется таким образом, что проверка на нуль не является необходимым.

Вместо:

if( null != aObject && aObject instanceof String )
{
    ...
}

просто использовать:

if( aObject instanceof String )
{
    ...
}
Ответил 19/01/2009 в 16:01
источник пользователем

голоса
142

Передача управления в блоке, наконец, выбрасывает любое исключение. Следующий код не бросает RuntimeException - это теряется.

public static void doSomething() {
    try {
      //Normally you would have code that doesn't explicitly appear 
      //to throw exceptions so it would be harder to see the problem.
      throw new RuntimeException();
    } finally {
      return;
    }
  }

От http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

Ответил 15/09/2008 в 17:49
источник пользователем

голоса
134

Учитывая методы и конструкторы в перечислениях меня удивил. Например:

enum Cats {
  FELIX(2), SHEEBA(3), RUFUS(7);

  private int mAge;
  Cats(int age) {
    mAge = age;
  }
  public int getAge() {
    return mAge;
   }
}

Вы даже можете иметь «постоянное конкретное тело класса», который позволяет определенное значение перечисления переопределить методы.

Больше документации здесь .

Ответил 09/09/2008 в 22:10
источник пользователем

голоса
121

В PARAMS типа для общих методов можно указать явно, как так:

Collections.<String,Integer>emptyMap()
Ответил 11/09/2008 в 03:09
источник пользователем

голоса
112

Вы можете использовать перечисления для реализации интерфейса.

public interface Room {
   public Room north();
   public Room south();
   public Room east();
   public Room west();
}

public enum Rooms implements Room {
   FIRST {
      public Room north() {
         return SECOND;
      }
   },
   SECOND {
      public Room south() {
         return FIRST;
      }
   }

   public Room north() { return null; }
   public Room south() { return null; }
   public Room east() { return null; }
   public Room west() { return null; }
}

EDIT: Много лет спустя ....

Я использую эту функцию здесь

public enum AffinityStrategies implements AffinityStrategy {

https://github.com/peter-lawrey/Java-Thread-Affinity/blob/master/src/main/java/vanilla/java/affinity/AffinityStrategies.java

Используя интерфейс, разработчики могут определять свои собственные стратегии. С помощью enumсредства можно определить коллекцию (из пяти) , построенных в них.

Ответил 18/02/2009 в 22:10
источник пользователем

голоса
104

На Java 1.5, Java теперь имеет гораздо более чистый синтаксис для написания функций переменной валентности. Таким образом, вместо того, чтобы просто передавая массив, теперь вы можете сделать следующее

public void foo(String... bars) {
   for (String bar: bars)
      System.out.println(bar);
}

бары автоматически преобразуются в массив указанного типа. Не огромная победа, но победа, тем не менее.

Ответил 03/11/2008 в 18:02
источник пользователем

голоса
93

Мой любимый: сбросить все стек нить следы на стандартный вывод.

окна: CTRL- Breakв вашем ява Cmd / консольном окне

UNIX: kill -3 PID

Ответил 17/09/2008 в 14:23
источник пользователем

голоса
89

Несколько человек были размещены около экземпляра инициализаторах, вот хорошо использовать для этого:

Map map = new HashMap() {{
    put("a key", "a value");
    put("another key", "another value");
}};

Есть быстрый способ инициализации карты, если вы просто делаете что-то быстро и просто.

Или использовать его, чтобы быстро создать прототип поворотной рамы:

JFrame frame = new JFrame();

JPanel panel = new JPanel(); 

panel.add( new JLabel("Hey there"){{ 
    setBackground(Color.black);
    setForeground( Color.white);
}});

panel.add( new JButton("Ok"){{
    addActionListener( new ActionListener(){
        public void actionPerformed( ActionEvent ae ){
            System.out.println("Button pushed");
        }
     });
 }});


 frame.add( panel );

Конечно, это может быть злоупотребляли:

    JFrame frame = new JFrame(){{
         add( new JPanel(){{
               add( new JLabel("Hey there"){{ 
                    setBackground(Color.black);
                    setForeground( Color.white);
                }});

                add( new JButton("Ok"){{
                    addActionListener( new ActionListener(){
                        public void actionPerformed( ActionEvent ae ){
                            System.out.println("Button pushed");
                        }
                     });
                 }});
        }});
    }};
Ответил 27/10/2008 в 01:12
источник пользователем

голоса
88

Динамические прокси (добавлено в версии 1.3) позволяет определить новый тип во время выполнения, соответствующий интерфейс. Это пригодится удивительное количество раз.

Ответил 03/09/2008 в 02:29
источник пользователем

голоса
82

Окончательные инициализации могут быть отложены.

Он уверен, что даже сложный поток возвращаемых значений логических всегда установлены. Это слишком легко пропустить случай и вернуть нуль случайно. Это не делает возвращение нулевой невозможно, просто очевидно, что это нарочно:

public Object getElementAt(int index) {
    final Object element;
    if (index == 0) {
         element = "Result 1";
    } else if (index == 1) {
         element = "Result 2";
    } else {
         element = "Result 3";
    }
    return element;
}
Ответил 03/10/2008 в 22:59
источник пользователем

голоса
62

Я думаю, что еще один «забывают» особенность Java является самой JVM. Это, вероятно, лучший VM доступны. И он поддерживает множество интересных и полезных языков (Jython, JRuby, Scala, Groovy). Все эти языки могут легко и беспрепятственно сотрудничать.

Если вы разрабатываете новый язык (как и в случае-лестницы), вы сразу имеете все существующие библиотеки доступны, и ваш язык, поэтому «полезно» с самого начала.

Все эти языки используют гиперобъект оптимизаций. VM очень хорошо контролировать и отладку.

Ответил 19/08/2008 в 17:47
источник пользователем

голоса
58

Вы можете задать анонимный подкласс и непосредственно вызвать метод на него, даже если он не реализует ни одного интерфейса.

new Object() {
  void foo(String s) {
    System.out.println(s);
  }
}.foo("Hello");
Ответил 22/06/2009 в 02:17
источник пользователем

голоса
56

AsList метод java.util.Arraysпозволяет хорошее сочетание, общих списков параметров методов и Autoboxing:

List<Integer> ints = Arrays.asList(1,2,3);
Ответил 15/09/2008 в 16:55
источник пользователем

голоса
53

Используя это ключевое слово для доступа к полям / методам , содержащего класс от внутреннего класса. В ниже, скорее надуманный пример, мы хотим использовать sortAscending поле контейнерного класса из анонимного внутреннего класса. Использование ContainerClass.this.sortAscending вместо this.sortAscending делает трюк.

import java.util.Comparator;

public class ContainerClass {
boolean sortAscending;
public Comparator createComparator(final boolean sortAscending){
    Comparator comparator = new Comparator<Integer>() {

        public int compare(Integer o1, Integer o2) {
            if (sortAscending || ContainerClass.this.sortAscending) {
                return o1 - o2;
            } else {
                return o2 - o1;
            }
        }

    };
    return comparator;
}
}
Ответил 19/09/2008 в 14:02
источник пользователем

голоса
52

Не действительно особенность, но забавный трюк, который я обнаружил недавно в каком-то веб-странице:

class Example
{
  public static void main(String[] args)
  {
    System.out.println("Hello World!");
    http://Phi.Lho.free.fr

    System.exit(0);
  }
}

является правильной программой Java (хотя она генерирует предупреждение). Если вы не видите, почему, см ответ Грегори! ;-) Ну, подсветка синтаксиса здесь также дает подсказку!

Ответил 17/09/2008 в 12:39
источник пользователем

голоса
46

Это не совсем «скрытые возможности» и не очень полезно, но может быть очень интересно в некоторых случаях:
Класс sun.misc.Unsafe - позволит осуществлять непосредственное управление памятью в Java (вы можете даже написать самомодифицирующийся Java коду это , если вы попробуете много):

public class UnsafeUtil {

    public static Unsafe unsafe;
    private static long fieldOffset;
    private static UnsafeUtil instance = new UnsafeUtil();

    private Object obj;

    static {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);

            unsafe = (Unsafe)f.get(null);
            fieldOffset = unsafe.objectFieldOffset(UnsafeUtil.class.getDeclaredField("obj"));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
}
Ответил 19/09/2008 в 14:35
источник пользователем

голоса
42

При работе в Swing , мне нравится скрытая Ctrl- Shift- F1особенность.

Он сваливает дерева компонентов текущего окна.
(Предполагая , что вы не связаны , что нажатие клавиши на что - то другое.)

Ответил 02/12/2009 в 17:28
источник пользователем

голоса
40

Каждый файл класса начинается с шестигранной значение 0xCAFEBABE , чтобы идентифицировать его в качестве действительного JVM байткод.

( Пояснение )

Ответил 19/02/2010 в 06:29
источник пользователем

голоса
38

Мой голос идет к java.util.concurrent с его параллельными коллекциями и гибкими исполнителями , позволяющих среди других пулов потоков, запланированные задачами и согласованные задачами. DelayQueue мой личный фаворит, где элементы доступны после заданной задержки.

java.util.Timer и TimerTask может быть безопасно развеялись.

Кроме того, не совсем скрыты, но в другом пакете из других классов, связанных с датой и временем. java.util.concurrent.TimeUnit полезно при преобразовании между наносекунд, микросекунд, миллисекунд и секунд.

Он читает намного лучше, чем обычный SomeValue * 1000 или SomeValue / 1000.

Ответил 04/12/2008 в 20:51
источник пользователем

голоса
37

Не совсем частью языка Java, но javap дизассемблер, который поставляется с JDK Солнца не является широко известным или используется.

Ответил 10/09/2008 в 18:20
источник пользователем

голоса
37

Язык уровня утверждают , ключевое слово.

Ответил 19/08/2008 в 02:51
источник пользователем

голоса
36

Добавление для каждой петли-конструкции в 1,5 раза. I <3 это.

// For each Object, instantiated as foo, in myCollection
for(Object foo: myCollection) {
  System.out.println(foo.toString());
}

И может быть использовано в вложенными случаях:

for (Suit suit : suits)
  for (Rank rank : ranks)
    sortedDeck.add(new Card(suit, rank));

Для-каждая конструкция также применима к массивам, где она скрывает переменный индекс, а не итератор. Следующий метод возвращает сумму значений в качестве ИНТ массива:

// Returns the sum of the elements of a
int sum(int[] a) {
  int result = 0;
  for (int i : a)
    result += i;
  return result;
}

Ссылка на документацию Sun

Ответил 16/09/2008 в 19:35
источник пользователем

голоса
34

я лично обнаружил java.lang.Voidочень поздно - улучшает читаемость кода в сочетании с генериков, например ,Callable<Void>

Ответил 17/02/2009 в 14:25
источник пользователем

голоса
30

Пожалуй, самое удивительное, скрытые особенностью является класс sun.misc.Unsafe.

http://www.docjar.com/html/api/ClassLib/Common/sun/misc/Unsafe.java.html

Ты можешь;

  • Создать объект без вызова конструктора.
  • Бросьте любое исключение даже Exception, не заботясь о бросках положения о методах. (Есть другой способ сделать это я знаю)
  • Получить / набор случайно доступ полей объекта без использования отражения.
  • выделить / свободный / копировать / изменить размер блока памяти, который может быть длинным (64-бит) в размере.
  • Получить расположение полей в объекте или статических полей в классе.
  • независимо друг от друга блокировать и разблокировать блокировку объекта. (Например, синхронизация без блока)
  • определить класс из предоставленных кодов байт. Вместо того, чтобы загрузчик классов, определяющий, что байт-код должен быть. (Вы можете сделать это с отражением, а)

КСТАТИ: Неправильное использование этого класса убить JVM. Я не знаю, какой JVMs поддерживает этот класс так, чтобы его не портативные.

Ответил 11/06/2009 в 21:10
источник пользователем

голоса
29

Вот мой список.

Мой любимый (и страшное) скрытая функция является то, что вы можете бросить проверенные исключения из методов, которые не декларирующих бросить что-нибудь.

import java.rmi.RemoteException;

class Thrower {
    public static void spit(final Throwable exception) {
        class EvilThrower<T extends Throwable> {
            @SuppressWarnings("unchecked")
            private void sneakyThrow(Throwable exception) throws T {
                throw (T) exception;
            }
        }
        new EvilThrower<RuntimeException>().sneakyThrow(exception);
    }
}

public class ThrowerSample {
    public static void main( String[] args ) {
        Thrower.spit(new RemoteException("go unchecked!"));
    }
}

Кроме того, вы можете, как знать, что вы можете бросить «нуль» ...

public static void main(String[] args) {
     throw null;
}

Угадайте, что это печатает:

Long value = new Long(0);
System.out.println(value.equals(0));

И, думаю, что это возвращает:

public int returnSomething() {
    try {
        throw new RuntimeException("foo!");
    } finally {
        return 0;
    }
}

выше, не должно удивлять, хороших разработчиков.


В Java вы можете объявить массив в следующих допустимых способов:

String[] strings = new String[] { "foo", "bar" };
// the above is equivalent to the following:
String[] strings = { "foo", "bar" };

Поэтому следующий Java-код вполне допустим:

public class Foo {
    public void doSomething(String[] arg) {}

    public void example() {
        String[] strings = { "foo", "bar" };
        doSomething(strings);
    }
}

Есть ли действительная причина, почему, вместо того, следующий код не должен быть действительным?

public class Foo {

    public void doSomething(String[] arg) {}

    public void example() {
        doSomething({ "foo", "bar" });
    }
}

Я думаю, что выше синтаксис был бы действительная заменой к переменному числу аргументов, введенных в Java 5. И, более согласованного с ранее разрешенными декларациями массива.

Ответил 25/01/2010 в 10:45
источник пользователем

голоса
28

Shutdown Крючки. Это позволяет регистрировать поток , который будет создан немедленно , но начал только тогда , когда JVM заканчивается! Таким образом , это своего рода «глобальной Jvm финализации», и вы можете сделать полезные вещи в этой теме (например , закрытие Java RESSOURCES как встроенный сервер HSQLDB). Это работает с System.exit (), или с помощью CTRL-C / -15 убить (но не убивать -9 на Unix, конечно).

Кроме того, это довольно легко настроить.

            Runtime.getRuntime().addShutdownHook(new Thread() {
                  public void run() {
                      endApp();
                  }
            });;
Ответил 17/12/2009 в 00:47
источник пользователем

голоса
27

Значение:

new URL("http://www.yahoo.com").equals(new URL("http://209.191.93.52"))

есть true.

(От Java Puzzlers)

Ответил 27/10/2008 в 01:03
источник пользователем

голоса
26

Если вы много развития JavaBean и работать с поддержкой изменения свойств, вы вообще заводиться писать много сеттеров , как это:

public void setFoo(Foo aFoo){
  Foo old = this.foo;
  this.foo = aFoo;
  changeSupport.firePropertyChange("foo", old, aFoo);
}

Недавно я наткнулся на блог, который предложил более сжатое реализацию этого, что делает код намного проще написать:

public void setFoo(Foo aFoo){
  changeSupport.firePropertyChange("foo", this.foo, this.foo = aFoo);
}

Это на самом деле упрощена вещи до точки, где я был в состоянии настроить шаблон сеттер в Eclipse, так что метод будет создаваться автоматически.

Ответил 26/09/2008 в 04:30
источник пользователем

голоса
25

статический импорт в «усилить» язык, так что вы можете сделать хорошие буквальные вещи типа безопасными способами:

List<String> ls = List("a", "b", "c");

(Можно также сделать с картами, массивами, множествами).

http://gleichmann.wordpress.com/2008/01/13/building-your-own-literals-in-java-lists-and-arrays/

Принимая его дальше:

List<Map<String, String>> data = List(Map( o("name", "michael"), o("sex", "male")));
Ответил 19/08/2008 в 03:06
источник пользователем

голоса
23

Не так скрыто, но интересно.

Вы можете иметь «Здравствуй, мир» без основного метода (он бросает подумал NoSuchMethodError)

Первоначально отправленный RusselW на функции языка Strangest

public class WithoutMain {
    static {
        System.out.println("Look ma, no main!!");
        System.exit(0);
    }
}

$ java WithoutMain
Look ma, no main!!
Ответил 05/07/2010 в 19:22
источник пользователем

голоса
23

обработка Java делает ловкий трюк на определение переменной, если вы не используете инициализатор по умолчанию.

{
   ИНТ х;

   если (что угодно)
      х = 1;

   если (х == 1)
      ...
}

Это даст вам ошибку во время компиляции, что у вас есть путь, где X не правильно определен. Это помогло мне несколько раз, и я принял к рассмотрению инициализации по умолчанию, как это:

INT х = 0;
Указатель на строку = NULL;

быть плохой шаблон поскольку он блокирует эту информацию полезной проверки.

Тем не менее, иногда это трудно обойти - я должен был вернуться назад и отредактировать в = NULL, когда это имело смысл по умолчанию, но я никогда не ставил его в на первом проходе больше.

Ответил 06/10/2008 в 19:14
источник пользователем

голоса
23

В качестве стартера, я действительно ценю программное обеспечение для мониторинга Jconsole в Java 6, он решил несколько проблем для меня уже и я продолжаю находить новые применения для него.

Видимо JConsole был там уже в Java 5, но я считаю, что это улучшается сейчас и, по крайней мере работает гораздо стабильнее, как сейчас.

JConsole в Java 5: JConsole в Java 5

JConsole в Java 6: JConsole в Java 6

И пока вы на него, иметь хороший взгляд на других инструментах в серии: Java инструменты 6 по устранению неисправностей

Ответил 20/08/2008 в 12:30
источник пользователем

голоса
21

Это на самом деле не скрытая функция, но она дает мне большое удивление, когда я увидел это компилируется нормально:

public int aMethod(){
    http://www.google.com
    return 1;
}

причина , почему он компилирует, что линия http://www.google.com «HTTP:» часть обрабатывается компилятором как этикетки и остальной части строки является комментарием.

Итак, если вы хотите написать какой-нибудь Bizzare код (или запутанный код), просто положить много HTTP-адресов там. ;-)

Ответил 28/06/2010 в 05:36
источник пользователем

голоса
20

Вы можете объявить класс в методе:

public Foo foo(String in) {
    class FooFormat extends Format {
        public Object parse(String s, ParsePosition pp) { // parse stuff }
    }
    return (Foo) new FooFormat().parse(in);

}
Ответил 28/09/2008 в 16:45
источник пользователем

голоса
19

Им потребовалось достаточно много времени, чтобы добавить поддержку для этого,

System Tray

Ответил 15/09/2008 в 16:50
источник пользователем

голоса
17

Самостоятельно переплете дженерики:

class SelfBounded<T extends SelfBounded<T>> {
}

http://www.artima.com/weblogs/viewpost.jsp?thread=136394

Ответил 10/09/2008 в 21:18
источник пользователем

голоса
17

Мне очень нравится переписанная Threading API из Java 1.6. Вызываемых объектов велики. Они в основном потоки с возвращаемым значением.

Ответил 19/08/2008 в 03:03
источник пользователем

голоса
16

Функция, с которой вы можете отобразить заставки для ваших приложений, основанных на Java Console.

Используйте инструмент командной строки javaили javawс помощью опции-splash

например:

java -splash:C:\myfolder\myimage.png -classpath myjarfile.jar com.my.package.MyClass

содержание C:\myfolder\myimage.pngбудет отображаться в центре экрана, когда вы выполнить класс «com.my.package.MyClass»

Ответил 27/11/2009 в 09:39
источник пользователем

голоса
16

О, я почти забыл эту маленькую жемчужину. Попробуйте это на любом запущенном процессе Java:

jmap -histo: жить PID

Вы получите гистограмму объектов живой кучи в данной виртуальной машине. Бесценный как быстрый способ, чтобы понять некоторые виды утечек памяти. Другой метод, я использую, чтобы предотвратить их, чтобы создавать и использовать размерно-ограниченных подклассов всех классов коллекций. Это вызывает быстрые сбои в из-под контроля коллекций, которые легко идентифицировать.

Ответил 26/11/2009 в 20:03
источник пользователем

голоса
16

List.subList возвращает представление о первоначальном списке

Документально, но мало известна особенность списков. Это позволяет работать с частями списка с изменениями зеркальных в исходном списке.

Список Подсписок (интермедиат fromIndex, внутр toIndex)

«Этот метод устраняет необходимость в операцию явного диапазона (подобный, которые обычно существуют для массивов). Любую операцию, которая ожидает список может быть использована в качестве операции диапазона, передавая вид Подсписка вместо целого списка. Например, следующая идиома удаляет диапазон элементов из списка:

       list.subList(from, to).clear();

Подобные идиомы могут быть построены для IndexOf и LastIndexOf, и все алгоритмы в классе Коллекции могут быть применены к подсписок «.

Ответил 17/02/2009 в 14:22
источник пользователем

голоса
16

Мне нравится статический импорт методов.

Например создать следующий класс Util:

package package.name;

public class util {

     private static void doStuff1(){
        //the end
     }

     private static String doStuff2(){
        return "the end";
     }

}

Затем использовать его как это.

import static package.name.util.*;

public class main{

     public static void main(String[] args){
          doStuff1(); // wee no more typing util.doStuff1()
          System.out.print(doStuff2()); // or util.doStuff2()
     }

}

Статический Импорт работает с любым классом, даже матом ...

import static java.lang.Math.*;
import static java.lang.System.out;
public class HelloWorld {
    public static void main(String[] args) {
        out.println("Hello World!");
        out.println("Considering a circle with a diameter of 5 cm, it has:");
        out.println("A circumference of " + (PI * 5) + "cm");
        out.println("And an area of " + (PI * pow(5,2)) + "sq. cm");
    }
}
Ответил 17/02/2009 в 13:56
источник пользователем

голоса
15

со статическим импортом вы можете сделать такие вещи, как:

List<String> myList = list("foo", "bar");
Set<String> mySet = set("foo", "bar");
Map<String, String> myMap = map(v("foo", "2"), v("bar", "3"));
Ответил 04/02/2009 в 18:19
источник пользователем

голоса
15

Javadoc - когда написано правильно (не всегда в случае с некоторыми разработчиками к сожалению), это дает вам четкое, последовательное описание того, что код должен делать, в отличие от того, что он на самом деле делает. Затем он может быть превращен в красивый просматриваемый набор HTML документации. При использовании непрерывной интеграции т.д., она может регулярно генерируется таким образом, все разработчики могут увидеть самые последние обновления.

Ответил 12/11/2008 в 17:59
источник пользователем

голоса
15

Не совсем особенность, но это заставляет меня хихикать , что gotoэто зарезервированное слово , которое не делает ничего , кроме побуждая JAVAC тыкать в глаза. Просто , чтобы напомнить вам , что вы находитесь в ОО-земле в настоящее время.

Ответил 20/08/2008 в 11:07
источник пользователем

голоса
14

Вы можете определить и вызывать методы анонимных внутренних классов.

Ну, они не то, что скрыто, но очень немногие люди знают, что они могут быть использованы для определения нового метода в классе и вызвать его, как это:

(new Object() {
    public String someMethod(){ 
        return "some value";
    }
}).someMethod();

Вероятно , это не очень часто , потому что не очень полезно либо, вы можете вызвать метод , который он только при определении его (или с помощью отражения)

Ответил 22/06/2010 в 00:04
источник пользователем

голоса
14

Strictfp ключевое слово. (Я никогда не видел, что это используется в настоящем приложении, хотя :)

Вы можете получить класс для примитивных типов, используя следующие обозначения: int.class, float.class и т.д. Очень полезно при выполнении отражения.

Окончательные массивы могут быть использованы для «возвращения» значения из анонимных внутренних классов (предупреждения, бесполезный пример ниже):

final boolean[] result = new boolean[1];
SwingUtilities.invokeAndWait(new Runnable() {
  public void run() { result[0] = true; }
});
Ответил 01/01/2009 в 06:19
источник пользователем

голоса
13

С-типа Е () :)

System.out.printf("%d %f %.4f", 3,Math.E,Math.E);

Выход: 3 2.718282 2,7183

Двоичный поиск (и это возвращаемое значение)

int[] q = new int[] { 1,3,4,5};
int position = Arrays.binarySearch(q, 2);

Подобно C #, если «2» не найден в массиве, он возвращает отрицательное значение, но если вы берете 1 по комплемент возвращаемого значения вы фактически получаете позицию, где «2» может быть вставлен.

В приведенном выше примере, позиция = -2 ~ позиция = 1, который является положение, в котором 2 должен быть вставлен ... это также позволяет найти «ближайший» матч в массиве.

Я думаю, что его довольно изящный ... :)

Ответил 30/06/2010 в 09:06
источник пользователем

голоса
13

Я знал , что Java 6 включает поддержку сценариев, но я только недавно обнаружил jrunscript , который может интерпретировать и запускать JavaScript (и, один предполагает, другие языки сценариев , такие как Groovy) в интерактивном режиме , то вроде оболочки Python или IRB в Рубине

Ответил 03/09/2008 в 01:33
источник пользователем

голоса
12

функция Part, часть заморачиваться: String в Java обработки, чтобы сделать его «появляются» родной тип (использование операторов на них, +, + =)

Будучи в состоянии написать:

String s = "A";
s += " String"; // so s == "A String"

очень удобно, но это просто синтаксический сахар для (т.е. компилируется в):

String s = new String("A");
s = new StringBuffer(s).append(" String").toString();

Ergo в создании экземпляра объекта и 2 вызовов методов для простой конкатенации. Представьте Строим длинную строку внутри цикла таким способом !? И все методы StringBuffer в объявляются синхронизированы. К счастью, в (я думаю) Java 5 они ввели StringBuilder, который идентичен StringBuffer без Syncronization.

Цикл таких, как:

String s = "";
for (int i = 0 ; i < 1000 ; ++i)
  s += " " + i; // Really an Object instantiation & 3 method invocations!

может (должно) быть переписан в вашем коде, как:

StringBuilder buf = new StringBuilder(); // Empty buffer
for (int i = 0 ; i < 1000 ; ++i)
  buf.append(' ').append(i); // Cut out the object instantiation & reduce to 2 method invocations
String s = buf.toString();

и будет работать примерно 80 +% быстрее, чем исходная петля! (До 180% в некоторых тестах я работать)

Ответил 04/06/2009 в 10:06
источник пользователем

голоса
12

Я знаю , что это был добавлен в версии 1.5 , но новый тип перечисления интересная особенность. Не имея использовать старую «ИНТ перечислимую шаблон» значительно помогло кучу моего кода. Проверьте JLS 8.9 для сладкого соуса на картошку!

Ответил 04/09/2008 в 16:55
источник пользователем

голоса
12

Это не совсем скрыто, но отражение невероятно полезное и мощное. Это здорово использовать простой Class.forName ( «...»). NewInstance (), где тип класса настраивается. Легко написать этот вид реализации фабрики.

Ответил 29/08/2008 в 20:17
источник пользователем

голоса
11

Я только (вос) узнал сегодня, что $ является юридическим названием метода или переменным в Java. В сочетании со статическим импортом может сделать какой-то немного более читаемый код, в зависимости от вашего зрения читаемого:

http://garbagecollected.org/2008/04/06/dollarmaps/

Ответил 28/07/2009 в 04:21
источник пользователем

голоса
11

Окончательный для переменных экземпляра:

Действительно полезный для многопоточной коды, и это делает его намного легче рассуждать о состоянии экземпляра и корректности. Не видел его много в контексте промышленности и часто не думали в классах Java.


Статическая {что-то}:

Используется для инициализации статических членов (также я предпочитаю статический метод, чтобы сделать это (потому что у него есть имя). Не думал.

Ответил 06/09/2008 в 10:07
источник пользователем

голоса
10

Используйте StringBuilderвместо StringBufferкогда вам не нужно синхронизировать управление включено в StringBuilder. Это увеличит производительность вашего приложения.

Улучшения в Java 7 будет даже лучше, чем любые скрытые возможности Java:

Не использовать эти бесконечные <> синтаксис в создании экземпляра:

Map<String, List<String>> anagrams = new HashMap<String, List<String>>();

// Can now be replaced with this:

Map<String, List<String>> anagrams = new HashMap<>();

Используйте строку в коммутаторе, вместо старого C междунар:

String s = "something";
switch(s) {
 case "quux":
    processQuux(s);
    // fall-through

  case "foo":
  case "bar":
    processFooOrBar(s);
    break;

  case "baz":
     processBaz(s);
    // fall-through

  default:
    processDefault(s);
    break;
}
  • Автоматическое управление ресурсами Ссылка

Этот старый код:

static void copy(String src, String dest) throws IOException {
    InputStream in = new FileInputStream(src);
    try {
        OutputStream out = new FileOutputStream(dest);
        try {
            byte[] buf = new byte[8 * 1024];
            int n;
            while ((n = in.read(buf)) >= 0)
                out.write(buf, 0, n);
        } finally {
            out.close();
        }
    } finally {
        in.close();
    }
}

Теперь можно заменить этим гораздо более простой код:

static void copy(String src, String dest) throws IOException {
    try (InputStream in = new FileInputStream(src);
            OutputStream out = new FileOutputStream(dest)) {
        byte[] buf = new byte[8192];
        int n;
        while ((n = in.read(buf)) >= 0)
            out.write(buf, 0, n);
    }
}
Ответил 04/11/2009 в 16:00
источник пользователем

голоса
10

Оптимизация трюк, который упрощает код, чтобы поддерживать и менее восприимчивы к параллельности ошибки.

public class Slow {
  /** Loop counter; initialized to 0. */
  private long i;

  public static void main( String args[] ) {
    Slow slow = new Slow();

    slow.run();
  }

  private void run() {
    while( i++ < 10000000000L )
      ;
  }
}

$ Время ява Slow
реального 0m15.397s
$ времени Java Slow
реального 0m20.012s
$ времени Java Slow
реальных 0m18.645s

Средний балл: 18.018s

public class Fast {
  /** Loop counter; initialized to 0. */
  private long i;

  public static void main( String args[] ) {
    Fast fast = new Fast();

    fast.run();
  }

  private void run() {
    long i = getI();

    while( i++ < 10000000000L )
      ;

    setI( i );
  }

  private long setI( long i ) {
    this.i = i;
  }

  private long getI() {
    return this.i;
  }
}

$ Времени ява быстрой
реального 0m12.003s
$ время ява Быстрая
реальные 0m9.840s
$ времени Java Быстрый
реальный 0m9.686s

Средний балл: 10.509s

Это требует большего количества байт-кодов, чтобы ссылаться на переменную класса, чем области видимости переменной Метод-области действия. Добавление вызова метода предварительного критической петли добавляет немного накладные расходы (и вызов может быть встраиваемым компилятором в любом случае).

Еще одно преимущество этого метода (всегда с использованием аксессоров) является то , что он устраняет потенциальную ошибку в Slow классе. Если второй поток были постоянно сбросить значение I 0 (по телефону slow.setI( 0 ), например), то Медленный класс никогда не мог закончить свой цикл. Вызов аксессор и использование локальной переменной исключает такую возможность.

Испытано с помощью J2SE 1.6.0_13 на Linux 2.6.27-14.

Ответил 22/06/2009 в 03:46
источник пользователем

голоса
10

«Уста» является ключевым словом, но вы не можете использовать его.

int const = 1;   // "not a statement"
const int i = 1; // "illegal start of expression"

Я предполагаю, что авторы компилятора думал, что это может быть использовано в будущем, и они лучше держать защищены.

Ответил 16/09/2008 в 21:01
источник пользователем

голоса
9

Я могу добавить объект сканера. Это лучший для синтаксического анализа.

String input = "1 fish 2 fish red fish blue fish";
Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
System.out.println(s.nextInt());
System.out.println(s.nextInt());
System.out.println(s.next());
System.out.println(s.next());
s.close();
Ответил 09/06/2010 в 10:07
источник пользователем

голоса
9

Идентификаторы могут содержать иностранные символы языка как умляуты:

вместо:

String title="";

кто-то может написать:

String Überschrift="";
Ответил 09/01/2010 в 21:04
источник пользователем

голоса
9

Что-то, что действительно удивило меня был механизм пользовательских сериализации.

Хотя эти методы являются частными !! , Они « таинственно » вызывается JVM во время сериализации объекта.

private void writeObject(ObjectOutputStream out) throws IOException;
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;

Таким образом, вы можете создать свои собственные сериализации, чтобы сделать его более «все» (безопасно, быстро, редко, легко и т.д.)

Это то, что действительно следует обратить внимание, если много информации должен проходить через узлы. Механизм сериализации может быть изменен, чтобы отправить половину данных. Есть много раз, когда узкие места находятся не на платформе, но в размере, который послал корыто провода, могут сэкономить вам тысячи библиотек на аппаратном уровне.

Вот статья. http://java.sun.com/developer/technicalArticles/Programming/serialization/

Ответил 27/09/2008 в 02:11
источник пользователем

голоса
9

Как о свойствах файлов в вашем выборе кодировок? Раньше, когда вы загрузили свои свойства, вы предоставили InputStream и load()метод декодируется как ISO-8859-1. Вы могли бы на самом деле сохранить файл в какой - либо другой кодировке, но вы должны были использовать отвратительный хак , как это после загрузки , чтобы правильно декодировать данные:

String realProp = new String(prop.getBytes("ISO-8859-1"), "UTF-8");

Но, как в JDK 1.6, есть load()метод , который принимает читатель вместо InputStream, который означает , что вы можете использовать правильную кодировку с самого начала (есть также store()метод , который принимает Writer). Это кажется довольно большим делом для меня, но это , кажется, был пробрались в JDK, без лишнего шума вообще. Я только наткнулся на него несколько недель назад, и быстрый поиск Google появился только один проходной упоминания о нем.

Ответил 24/09/2008 в 20:37
источник пользователем

голоса
8

Большинство людей не знают, что они могут клонировать массив.

int[] arr = {1, 2, 3};
int[] arr2 = arr.clone();
Ответил 20/08/2009 в 12:45
источник пользователем

голоса
8

Люди иногда немного удивлены, когда они понимают, что это можно назвать частные методы и доступ / изменить личные поля с помощью отражения ...

Рассмотрим следующий класс:

public class Foo {
    private int bar;

    public Foo() {
        setBar(17);
    }

    private void setBar(int bar) {
        this.bar=bar;
    }

    public int getBar() {
        return bar;
    }

    public String toString() {
        return "Foo[bar="+bar+"]";
    }
}

Выполнение этой программы ...

import java.lang.reflect.*;

public class AccessibleExample {
    public static void main(String[] args)
        throws NoSuchMethodException,IllegalAccessException, InvocationTargetException, NoSuchFieldException {
        Foo foo=new Foo();
        System.out.println(foo);

        Method method=Foo.class.getDeclaredMethod("setBar", int.class);
        method.setAccessible(true);
        method.invoke(foo, 42);

        System.out.println(foo);
        Field field=Foo.class.getDeclaredField("bar");
        field.setAccessible(true);
        field.set(foo, 23);
        System.out.println(foo);
    }
}

... даст следующий результат:

Foo[bar=17]
Foo[bar=42]
Foo[bar=23]
Ответил 03/06/2009 в 15:32
источник пользователем

голоса
8

Аннотация API обработки из Java 6 выглядит очень перспективным для генерации кода и статической верификации кода.

Ответил 29/09/2008 в 12:09
источник пользователем

голоса
7

На самом деле, что я люблю Java, как несколько скрытых уловок есть. Это очень очевидный язык. Настолько, что после 15 лет, почти каждый один я могу думать уже перечислены на этих страницах.

Возможно, большинство людей знают, что Collections.synchronizedList () добавляет синхронизацию списка. То, что вы не можете знать, если вы не читали документацию, что вы можете безопасно итерацию по элементам этого списка синхронизации на самом списке объектов.

CopyOnWriteArrayList могут быть неизвестны некоторые, и будущее представляет собой интересный способ абстрагироваться многопоточного доступа результата.

Вы можете прикрепить к виртуальным машинам (локальным или удаленным), получить информацию о GC деятельности, использовании памяти, дескрипторах файлов и даже объект размеров через различное управление, агент и присоединять API.

Хотя TimeUnit, пожалуй, лучше, чем длинные, я предпочитаю класс Продолжительность калитку в.

Ответил 26/11/2009 в 19:43
источник пользователем

голоса
7

Вы можете построить Sprintf стиль строки, используя string.Format ().

String w = "world";
String s = String.format("Hello %s %d", w, 3);

Конечно, Вы можете также использовать специальные определители для изменения выхода.

Подробнее здесь: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Formatter.html#syntax

Ответил 04/02/2009 в 17:52
источник пользователем

голоса
7

Вы можете получить доступ конечных локальных переменных и параметров в блоках инициализации и методы локальных классов. Учти это:

    final String foo = "42";
    new Thread() {
        public void run() {
             dowhatever(foo);
        }
    }.start();

Немного как закрытие, не так ли?

Ответил 23/10/2008 в 15:18
источник пользователем

голоса
7

Сила вы можете иметь над сборщиком мусора , и как она управляет коллекцией объектов является очень мощным, особенно для длительного бега и чувствительных ко времени приложений. Она начинается со слабыми, мягкими, и фантомные ссылки в пакете java.lang.ref. Посмотрите на тех, особенно для строительных кэшей (есть java.util.WeakHashMap уже). Теперь копать немного глубже в ReferenceQueue , и вы начинаете иметь еще больший контроль. Наконец захватить документы на сборщик мусора себя , и вы будете в состоянии контролировать , как часто он работает, размеры различных областей сбора, а также типы алгоритмов , используемых (для Java 5 см http://java.sun.com/docs /hotspot/gc5.0/gc_tuning_5.html ).

Ответил 17/09/2008 в 18:37
источник пользователем

голоса
7

JVisualVM из каталога бен в распределении JDK. Мониторинг и даже профилирование любого Java-приложение, даже тот, который вы не начать с какими-либо специальными параметрами. Только в последних версиях Java 6SE JDK.

Ответил 15/09/2008 в 17:19
источник пользователем

голоса
6

Не читал об этом

Integer a = 1;
Integer b = 1;
Integer c = new Integer(1);
Integer d = new Integer(1);

Integer e = 128;
Integer f = 128;

assertTrue (a == b);   // again: this is true!
assertFalse(e == f); // again: this is false!
assertFalse(c == d);   // again: this is false!

подробнее об этом с помощью функции поиска пула Java-целочисленного (внутреннего кэша «» от -128 до 127 для Autoboxing) или посмотреть в Integer.valueOf

Ответил 22/01/2010 в 23:33
источник пользователем

голоса
6

Исходный код URL-адрес. Например, здесь есть какой-то легальный источник Java-код:

http://google.com

(Да, это было в Java Puzzlers. Я смеялся ...)

Ответил 12/05/2009 в 04:47
источник пользователем

голоса
6

Экземпляры одного и того же класса могут получить доступ к закрытым членам других случаях:

class Thing {
  private int x;

  public int addThings(Thing t2) {
    return this.x + t2.x;  // Can access t2's private value!
  }
}
Ответил 26/11/2008 в 20:04
источник пользователем

голоса
6

Некоторые приемы управления потоком, finallyвокруг returnзаявления:

int getCount() { 
  try { return 1; }
  finally { System.out.println("Bye!"); }
}

Правила определенного присваивания будет проверять , что окончательная переменная всегда назначается с помощью простого анализа потока управления:

final int foo;
if(...)
  foo = 1;
else
  throw new Exception();
foo+1;
Ответил 15/09/2008 в 17:08
источник пользователем

голоса
6

Новый Джошуа Блоха Эффективное Java является хорошим ресурсом.

Ответил 08/09/2008 в 14:24
источник пользователем

голоса
5

Java 6 (от Солнца) поставляется с встроенным интерпретатором JavaScrip.

http://java.sun.com/javase/6/docs/technotes/guides/scripting/programmer_guide/index.html#jsengine

Ответил 14/01/2010 в 12:59
источник пользователем

голоса
5

Запятая и массив. Это является законным синтаксис: Строка с [] = {
"123",
"234" ,
};

Ответил 20/08/2009 в 11:06
источник пользователем

голоса
5

Уже упоминалось , что окончательный массив может быть использован для передачи переменной из анонимных внутренних классов.

Другой, возможно, лучше и менее уродливый подход, хотя это использовать AtomicReference (или AtomicBoolean / AtomicInteger / ...) класса из java.util.concurrent.atomic пакета.

Одним из преимуществ в этом является то , что эти классы также предоставляют такие методы , как compareAndSet, что может быть полезно , если вы создаете несколько потоков , которые могут изменить ту же переменную.


Другая полезная родственная картина:

final AtomicBoolean dataMsgReceived = new AtomicBoolean(false);
final AtomicReference<Message> message = new AtomicReference<Message>();
withMessageHandler(new MessageHandler() {
    public void handleMessage(Message msg) {
         if (msg.isData()) {
             synchronized (dataMsgReceived) {
                 message.set(msg);
                 dataMsgReceived.set(true);
                 dataMsgReceived.notifyAll();
             }
         }
    }
}, new Interruptible() {
    public void run() throws InterruptedException {
        synchronized (dataMsgReceived) {
            while (!dataMsgReceived.get()) {
                dataMsgReceived.wait();
            }
        }
    }
});

В этом конкретном примере мы могли бы просто ждали на сообщение, чтобы он стал не равен нулю, однако нуль часто может быть допустимым значением, а затем вам нужно использовать отдельный флаг, чтобы закончить ждать.

waitMessageHandler(…)выше еще один полезный шаблон: она устанавливает обработчик где - то, а затем приступает к выполнению прерываемого , который может выбросить исключение, а затем удаляет обработчик в конце концов блока, например , так:

private final AtomicReference<MessageHandler> messageHandler = new AtomicReference<MessageHandler>();
public void withMessageHandler(MessageHandler handler, Interruptible logic) throws InterruptedException {
    synchronized (messageHandler) {
        try {
            messageHandler.set(handler);
            logic.run();
        } finally {
            messageHandler.set(null);
        }
    }
}

Здесь я предполагаю , что MessageHandler «s (если оно не равно нулю) handleMessage(…)метод вызывается другим потоком при получении сообщения. MessageHandler не должен быть просто из MessageHandler типа: таким образом вы будете синхронизировать меняющуюся переменный, которая явно ошибка.

Конечно, не нужно быть InterruptedException , это может быть что - то вроде IOException , или что - то имеет смысл в определенной части кода.

Ответил 14/08/2009 в 10:35
источник пользователем

голоса
5

Читайте «Java Puzzlers» Джошуа Блох, и вы будете как просвещенными и ужаснулся.

Ответил 20/04/2009 в 04:26
источник пользователем

голоса
5

Типы перекрестков позволяют вам (любопытный Сорт) делать перечисления, которые имеют иерархию наследования. Вы не можете наследовать реализации, но вы можете делегировать его вспомогательный класс.

enum Foo1 implements Bar {}
enum Foo2 implements Bar {}

class HelperClass {
   static <T extends Enum<T> & Bar> void fooBar(T the enum) {}
}

Это полезно, когда у вас есть несколько различных перечислений, которые реализуют какой-то шаблон. Например, число пар перечислений, которые имеют отношения родитель-ребенок.

enum PrimaryColor {Red, Green, Blue;}
enum PastelColor {Pink, HotPink, Rockmelon, SkyBlue, BabyBlue;}

enum TransportMedium {Land, Sea, Air;}
enum Vehicle {Car, Truck, BigBoat, LittleBoat, JetFighter, HotAirBaloon;}

Вы можете написать общие методы, которые говорят, «Хорошо, учитывая значение перечисления того родитель некоторых других значений перечислений, какой процент от всех возможных детей перечислений типа ребенка имеет конкретное родительское значение в качестве родителя?», И есть все типизированные и сделано без литья. (Например: что «море» составляет 33% от всех возможных транспортных средств, и «Green» 20% всех возможных пастель).

Код выглядит следующим образом. Это довольно неприятное, но есть способы, чтобы сделать его лучше. Обратите внимание на particuar, что «лист» классы сами являются весьма аккуратным - общие классы заявлений, которые ужасно некрасиво, но вы только писать их onece. После того, как общие классы есть, то с их помощью легко.

import java.util.EnumSet;

import javax.swing.JComponent;

public class zz extends JComponent {

    public static void main(String[] args) {
        System.out.println(PrimaryColor.Green + " " + ParentUtil.pctOf(PrimaryColor.Green) + "%");
        System.out.println(TransportMedium.Air + " " + ParentUtil.pctOf(TransportMedium.Air) + "%");
    }


}

class ParentUtil {
    private ParentUtil(){}
    static <P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> //
    float pctOf(P parent) {
        return (float) parent.getChildren().size() / //
                (float) EnumSet.allOf(parent.getChildClass()).size() //
                * 100f;
    }
    public static <P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> //
    EnumSet<C> loadChildrenOf(P p) {
        EnumSet<C> cc = EnumSet.noneOf(p.getChildClass());
        for(C c: EnumSet.allOf(p.getChildClass())) {
            if(c.getParent() == p) {
                cc.add(c);
            }
        }
        return cc;
    }
}

interface Parent<P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> {
    Class<C> getChildClass();

    EnumSet<C> getChildren();
}

interface Child<P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> {
    Class<P> getParentClass();

    P getParent();
}

enum PrimaryColor implements Parent<PrimaryColor, PastelColor> {
    Red, Green, Blue;

    private EnumSet<PastelColor>    children;

    public Class<PastelColor> getChildClass() {
        return PastelColor.class;
    }

    public EnumSet<PastelColor> getChildren() {
        if(children == null) children=ParentUtil.loadChildrenOf(this);
        return children;
    }
}

enum PastelColor implements Child<PrimaryColor, PastelColor> {
    Pink(PrimaryColor.Red), HotPink(PrimaryColor.Red), //
    Rockmelon(PrimaryColor.Green), //
    SkyBlue(PrimaryColor.Blue), BabyBlue(PrimaryColor.Blue);

    final PrimaryColor  parent;

    private PastelColor(PrimaryColor parent) {
        this.parent = parent;
    }

    public Class<PrimaryColor> getParentClass() {
        return PrimaryColor.class;
    }

    public PrimaryColor getParent() {
        return parent;
    }
}

enum TransportMedium implements Parent<TransportMedium, Vehicle> {
    Land, Sea, Air;

    private EnumSet<Vehicle>    children;

    public Class<Vehicle> getChildClass() {
        return Vehicle.class;
    }

    public EnumSet<Vehicle> getChildren() {
        if(children == null) children=ParentUtil.loadChildrenOf(this);
        return children;
    }
}

enum Vehicle implements Child<TransportMedium, Vehicle> {
    Car(TransportMedium.Land), Truck(TransportMedium.Land), //
    BigBoat(TransportMedium.Sea), LittleBoat(TransportMedium.Sea), //
    JetFighter(TransportMedium.Air), HotAirBaloon(TransportMedium.Air);

    private final TransportMedium   parent;

    private Vehicle(TransportMedium parent) {
        this.parent = parent;
    }

    public Class<TransportMedium> getParentClass() {
        return TransportMedium.class;
    }

    public TransportMedium getParent() {
        return parent;
    }
}
Ответил 22/02/2009 в 08:22
источник пользователем

голоса
5

Следующее поколение Java плагин находится в Java 1.6 Update 10, а затем имеет некоторые очень аккуратные черты:

  • Передайте параметр java_arguments передать аргументы в JVM, которая создается. Это позволяет контролировать объем памяти, данный апплет.
  • Создание отдельных загрузчики классов или даже отдельной виртуальной машины Java для каждого апплета.
  • Укажите версию виртуальной машины Java для использования.
  • Установка частичных Java ядра в тех случаях, когда вам нужно только подмножество функций в полной мере Java библиотек.
  • Улучшенная поддержка Windows Vista.
  • Поддержка (экспериментальная) перетащить апплет из браузера и он продолжает работать, когда вы уйдете.

Многие другие вещи, которые задокументированы здесь: http://jdk6.dev.java.net/plugin2/

Больше из этого выпуска здесь: http://jdk6.dev.java.net/6u10ea.html

Ответил 04/02/2009 в 16:58
источник пользователем

голоса
5

Строка параметризованного класс Factory.

Class.forName( className ).newInstance();

Загрузите ресурс (свойство файла, XML, XSLT, изображения и т.д.) из баночки развертывания файла .

this.getClass().getClassLoader().getResourceAsStream( ... ) ;
Ответил 26/09/2008 в 14:06
источник пользователем


голоса
4

Вы можете добавить во время выполнения проверки родовых типов с помощью Class<T>объекта, это очень удобно , когда класс создается в файле конфигурации где - то и нет никакого способа , чтобы добавить компиляции проверки времени для универсального типа класса. Вы не хотите, чтобы класс взорвать во время выполнения , если приложение случается быть настроено неправильно , и вы не хотите , все , что вам классы пронизаны например чеки.

public interface SomeInterface {
  void doSomething(Object o);
}
public abstract class RuntimeCheckingTemplate<T> {
  private Class<T> clazz;
  protected RuntimeChecking(Class<T> clazz) {
    this.clazz = clazz;
  }

  public void doSomething(Object o) {
    if (clazz.isInstance(o)) {
      doSomethingWithGeneric(clazz.cast(o));
    } else {
      // log it, do something by default, throw an exception, etc.
    }
  }

  protected abstract void doSomethingWithGeneric(T t);
}

public class ClassThatWorksWithStrings extends RuntimeCheckingTemplate<String> {
  public ClassThatWorksWithStrings() {
     super(String.class);
  }

  protected abstract void doSomethingWithGeneric(T t) {
    // Do something with the generic and know that a runtime exception won't occur 
    // because of a wrong type
  }
}
Ответил 03/03/2010 в 16:17
источник пользователем

голоса
4

Вы можете включить (это) внутри определений методов классов перечислений. Заставил меня кричать «Ужасающий» громко, когда я обнаружил, что это на самом деле работает.

Ответил 26/11/2009 в 18:57
источник пользователем

голоса
4

Видимо , с некоторыми отладочных версий есть вариант , который сбрасывает родной (JIT) код сборки из HotSpot: http://weblogs.java.net/blog/kohsuke/archive/2008/03/deep_dive_into.html

К сожалению, я не смог найти сборку по ссылке в этой должности, если кто-то может найти более точный URL, я хотел бы играть с ним.

Ответил 03/12/2008 в 07:21
источник пользователем

голоса
4

SwingWorker для легкого управления интерфейса обратных вызовов пользователей из фоновых потоков.

Ответил 20/11/2008 в 21:19
источник пользователем

голоса
4

ФУНКТОРЫ довольно прохладно. Они очень близки к функции указатель, который все, как правило, быстро сказать невозможно в Java.

Функторы в Java

Ответил 29/08/2008 в 20:36
источник пользователем

голоса
3

Несколько лет назад, когда я должен был сделать Java (1.4.x) Я хотел метод Eval () и Солнца Javac есть (был?) Написан на Java, так что это было просто связать tools.jar и использовать его с каким-то клеем-кода вокруг Это.

Ответил 04/10/2008 в 22:05
источник пользователем

голоса
3

Поскольку никто еще не сказал, что это все же (я думаю), моя любимая функция Auto бокса!

public class Example
{
    public static void main(String[] Args)
    {
         int a = 5;
         Integer b = a; // Box!
         System.out.println("A : " + a);
         System.out.println("B : " + b);
    }
}
Ответил 20/09/2008 в 05:14
источник пользователем

голоса
2

Вы можете переопределить метод и есть конструктор суперкласса назвать его (это может стать неожиданностью для программистов C ++.)

пример

Ответил 25/01/2010 в 08:20
источник пользователем

голоса
1

мне понравилось

  1. Javadoc taglet «s и доклет , которые позволяют настраивать вывод JavaDoc.
  2. JDK инструменты : jstat, jstack и т.д.
Ответил 29/01/2009 в 18:44
источник пользователем

голоса
0

Java Bean методы доступа к свойствам этого не нужно начинать с «получить» и «установить».

Даже Джош Блох получает это неправильно в Effective Java.

Ответил 22/06/2009 в 16:10
источник пользователем

голоса
-3

Я был удивлен, когда я первый заметил троичной-оператор, который приравнивает простой, если-то-другое заявление:

minVal = (a < b) ? a : b;
Ответил 09/04/2010 в 13:15
источник пользователем

голоса
-8

Удивляет меня, что интерфейс может наследовать несколько интерфейсов, но класс может распространяться только один класс.

Ответил 03/12/2009 в 08:08
источник пользователем

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more