Скрытые функции Java

Я знаю, что это было добавлено в выпуске 1.5, но новой перечислимый тип является замечательная особенность. Необходимость использовать старый "международный перечислимый шаблон" значительно помогла набору моего кода. JLS 8.9 Выезда для сладкого соуса на Вашем картофеле!

финал, например, переменные:

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

статичный {что-то;}:

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

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

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

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

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

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

final boolean[] result = new boolean[1];
SwingUtilities.invokeAndWait(new Runnable() {
  public void run() { result[0] = true; }
});

со статическим импортом можно сделать интересный материал как:

List<String> myList = list("foo", "bar");
Set<String> mySet = set("foo", "bar");
Map<String, String> myMap = map(v("foo", "2"), v("bar", "3"));

Едва ли функция, но это заставляет меня хихикать, что goto зарезервированное слово, которое не делает ничего кроме запроса javac для ввода по абсолютному адресу Вас в глазу. Только, чтобы напомнить Вам, что Вы находитесь на земле OO теперь.

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

, Например, создают следующий 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");
    }
}

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

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

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

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

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

Подобные идиомы могут быть созданы для indexOf и lastIndexOf, и все алгоритмы в классе Наборов могут быть применены к подсписку".

Самосвязанные дженерики:

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

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

Мне действительно нравится переписанный API Поточной обработки от Java 1.6. Callables являются большими. Они - в основном потоки с возвращаемым значением.

Это брало их достаточно долго для добавления поддержки этого,

Системный лоток

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

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

}

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

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

{
   int x;

   if(whatever)
      x=1;

   if(x == 1)
      ...
}

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

int x=0;
String s=null;

, чтобы быть плохим шаблоном, так как это блокирует эту полезную проверку.

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

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

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")));

Если Вы делаете большую разработку JavaBean и работаете с поддержкой изменения свойства, Вы обычно волнуете запись партия из методов set как это:

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);
}

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

Значение:

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

true.

(От Трудных вопросов Java)

Как начинающий я действительно ценю JConsole контролирующее программное обеспечение в Java 6, это уже решило несколько проблем для меня, и я продолжаю находить новое использование для него.

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

JConsole в Java 5: JConsole в Java 5

JConsole в Java 6: JConsole в Java 6

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

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

Возможность писать:

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

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

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

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

Цикл, такой как:

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% в некоторых тестах, которые я проводил)

Возможно, самая удивительная скрытая функция - это класс sun.misc.Unsafe.

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

Вы можете;

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

Кстати: неправильное использование этого класса приведет к уничтожению JVM. Я не знаю, какие JVM поддерживают этот класс, поэтому его нельзя переносить.

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

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

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

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

например:

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

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

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

jmap -histo: live PID

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

Shutdown Hooks. This allows to register a thread that will be created immediatly but started only when the JVM ends ! So it is some kind of "global jvm finalizer", and you can make useful stuff in this thread (for example shutting down java ressources like an embedded hsqldb server). This works with System.exit(), or with CTRL-C / kill -15 (but not with kill -9 on unix, of course).

Moreover it's pretty easy to set up.

            Runtime.getRuntime().addShutdownHook(new Thread() {
                  public void run() {
                      endApp();
                  }
            });;

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

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

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. и, более согласованным с ранее допущенными объявлениями массива.

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

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

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

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

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

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

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

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

C-стиль printf ():)

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 ... она также позволяет вам найти «ближайшее» совпадение в массиве.

Я думаю, это довольно здорово ... :)

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

Вы можете иметь "Hello, world" без метода main (он бросает NoSuchMethodError thought)

Originally posted by RusselW on Самая странная особенность языка

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

$ java WithoutMain
Look ma, no main!!