Yararlı Eclipse Java kod şablonları arama [kapalı]

Eclipse'de çeşitli Java kod şablonları oluşturabilirsiniz.

Pencere> Tercihler> Java> Editör> Şablonlar

Örneğin

sysout şu adrese genişletildi:

System.out.println(${word_selection}${});${cursor}

Bunu, sysoutardından şunu yazarak etkinleştirebilirsiniz .CTRL+SPACE

Şu anda hangi yararlı Java kodu şablonlarını kullanıyorsunuz? Adını ve açıklamasını ve neden harika olduğunu ekleyin.

Yerleşik mevcut bir özellikten ziyade bir şablonun orijinal / yeni bir kullanımını arıyorum.

• Log4J logger oluştur
• Ekrandan SWT rengi alın
• Syncexec - Eclipse Çerçevesi
• Singleton Kalıbı / Enum Singleton Üretimi
• Readfile
• İnş
• Traceout
• Dizeyi Biçimlendir
• Yorum Kodu İncelemesi
• Dize biçimi
• Sonunda Kilitlemeyi Deneyin
• Mesaj Biçimi i18n ve günlük
• Equalsbuilder
• Hashcodebuilder
• Bahar Nesnesi Enjeksiyonu
• FileOutputStream Oluştur

Aşağıdaki kod şablonları hem bir günlükçü oluşturur hem de gerekirse doğru içe aktarımları oluşturur.

SLF4J

${:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}
private static final Logger LOG = LoggerFactory.getLogger(${enclosing_type}.class);

Log4J 2

${:import(org.apache.logging.log4j.LogManager,org.apache.logging.log4j.Logger)} 
private static final Logger LOG = LogManager.getLogger(${enclosing_type}.class); 

Log4J

${:import(org.apache.log4j.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class);

Kaynak .

Temmuz

${:import(java.util.logging.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class.getName());

Bazı ek şablonlar: Link I - Link II

Bunu beğendim:

readfile

 ${:import(java.io.BufferedReader,  
           java.io.FileNotFoundException,  
           java.io.FileReader,  
           java.io.IOException)}  
 BufferedReader in = null;  
 try {  
    in = new BufferedReader(new FileReader(${fileName}));  
    String line;  
    while ((line = in.readLine()) != null) {  
       ${process}  
    }  
 }  
 catch (FileNotFoundException e) {  
    logger.error(e) ;  
 }  
 catch (IOException e) {  
    logger.error(e) ;  
 } finally {  
    if(in != null) in.close();  
 }  
 ${cursor} 

GÜNCELLEME : Bu şablonun Java 7 sürümü:

${:import(java.nio.file.Files,
          java.nio.file.Paths,
          java.nio.charset.Charset,
          java.io.IOException,
          java.io.BufferedReader)}
try (BufferedReader in = Files.newBufferedReader(Paths.get(${fileName:var(String)}),
                                                 Charset.forName("UTF-8"))) {
    String line = null;
    while ((line = in.readLine()) != null) {
        ${cursor}
    }
} catch (IOException e) {
    // ${todo}: handle exception
}

Bir dizeyi biçimlendirme

MessageFormat - seçimi bir MessageFormat ile çevreleyin.

 ${:import(java.text.MessageFormat)} 
 MessageFormat.format(${word_selection}, ${cursor})

Bu, bir imleci bir dizeye taşımamı, seçimi tüm dizgiye (Shift-Alt-Up), ardından Ctrl-Space'i iki kez genişletmemi sağlar.

Seçimi kilitle

kilitle - seçili çizgileri son olarak kilitlemeyi deneyin. Bir kilit değişkeninin varlığını varsayalım.

${lock}.acquire();
try {
    ${line_selection}
    ${cursor}
} finally {
    ${lock}.release();
}

NB ${line_selection}şablonları Surround With menüsünde (Alt-Shift-Z) görünür.

Ölü bir yazı tekmelediğimi biliyorum, ancak bunu tamamlama uğruna paylaşmak istedim:

Kusurlu çift kontrollu kilitleme tasarımının üstesinden gelen tekli nesil şablonun doğru bir versiyonu (yukarıda tartışılmış ve başka yerde belirtilmiştir)

Singleton Oluşturma Şablonu: Bunu adlandırıncreatesingleton

static enum Singleton {
    INSTANCE;

    private static final ${enclosing_type} singleton = new ${enclosing_type}();

    public ${enclosing_type} getSingleton() {
        return singleton;
    }
}
${cursor}

Yukarıdakiler kullanılarak oluşturulan tek tonlara erişmek için:

Singleton referans Şablonu: Bunu adlandırın getsingleton:

${type} ${newName} = ${type}.Singleton.INSTANCE.getSingleton();

Üzerinde yineleme yapmak için kod snippet'i ekleyin Map.entrySet():

Şablon:

${:import(java.util.Map.Entry)}
for (Entry<${keyType:argType(map, 0)}, ${valueType:argType(map, 1)}> ${entry} : ${map:var(java.util.Map)}.entrySet())
{
    ${keyType} ${key} = ${entry}.getKey();
    ${valueType} ${value} = ${entry}.getValue();
    ${cursor}
}

Oluşturulan Kod:

for (Entry<String, String> entry : properties.entrySet())
{
    String key = entry.getKey();
    String value = entry.getValue();
    |
}

Için log, üye değişken eklemek için yararlı bir küçük ditty.

private static Log log = LogFactory.getLog(${enclosing_type}.class);

Mockito ile bir alay oluşturun ("Java ifadeleri" bağlamında):

${:importStatic('org.mockito.Mockito.mock')}${Type} ${mockName} = mock(${Type}.class);

Ve "Java türü üyeler" de:

${:import(org.mockito.Mock)}@Mock
${Type} ${mockName};

Bir istisna atmak için geçersiz bir yöntemle alay et:

${:import(org.mockito.invocation.InvocationOnMock,org.mockito.stubbing.Answer)}
doThrow(${RuntimeException}.class).when(${mock:localVar}).${mockedMethod}(${args});

Bir şey yapmak için geçersiz bir yöntemle alay et:

${:import(org.mockito.invocation.InvocationOnMock,org.mockito.stubbing.Answer)}doAnswer(new Answer<Object>() {
public Object answer(InvocationOnMock invocation) throws Throwable {
    Object arg1 = invocation.getArguments()[0];
    return null;
}
}).when(${mock:localVar}).${mockedMethod}(${args});

Saldırıya uğrayan yöntemi tam olarak bir kez doğrulayın:

${:importStatic(org.mockito.Mockito.verify,org.mockito.Mockito.times)}
verify(${mock:localVar}, times(1)).${mockMethod}(${args});

Saldırıya uğrayan yöntemin hiçbir zaman çağrılmadığını doğrulayın:

${:importStatic(org.mockito.Mockito.verify,org.mockito.Mockito.never)}verify(${mock:localVar}, never()).${mockMethod}(${args});

Google Guava kullanan yeni bağlantılı liste (ve hashset ve hashmap için benzer):

${import:import(java.util.List,com.google.common.collect.Lists)}List<${T}> ${newName} = Lists.newLinkedList();

Ayrıca bir Test sınıfı üreten büyük bir şablon kullanın. İlgilenen herkesin özelleştirmesi gereken kısaltılmış bir parçası:

package ${enclosing_package};

import org.junit.*;
import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.junit.runner.RunWith;

// TODO autogenerated test stub
@RunWith(MockitoJUnitRunner.class)
public class ${primary_type_name} {

    @InjectMocks
    protected ${testedType} ${testedInstance};
    ${cursor}

    @Mock
    protected Logger logger;

    @Before
    public void setup() throws Exception {
    }

    @Test
    public void shouldXXX() throws Exception {
        // given

        // when
        // TODO autogenerated method stub

        // then
        fail("Not implemented.");
    }
}
// Here goes mockito+junit cheetsheet

Boş Kontroller!

if( ${word_selection} != null ){
    ${cursor}
}

if( ${word_selection} == null ){
    ${cursor}
}

Sevdiklerimden biri foreach :

for (${iterable_type} ${iterable_element} : ${iterable}) {
    ${cursor}
}

Ve traceout , bunu izleme için bir sürü kullanarak olduğumdan beri:

System.out.println("${enclosing_type}.${enclosing_method}()");

Ben sadece başka bir tane düşündüm ve bir gün internet üzerinden bulduk, const :

private static final ${type} ${name} = new ${type} ${cursor};

Sysout üzerinde küçük bir ipucu - Ben "sop" olarak yeniden adlandırmak istiyorum. Java libs başka hiçbir şey "sop" ile başlar, böylece hızla "sop" ve bom yazabilirsiniz, ekler.

Geçerli kapsamda değişken olan bir IllegalArgumentException istisnası (illarg):

throw new IllegalArgumentException(${var});

Daha iyi

throw new IllegalArgumentException("Invalid ${var} " + ${var});  

Kod üretimi için fantezi bir şey yok - ancak kod incelemeleri için oldukça yararlı

Benim şablon coderev düşük / med / yüksek var aşağıdakileri yapmak

/**
 * Code Review: Low Importance
 * 
 *
 * TODO: Insert problem with code here 
 *
 */

Ve sonra Görevler görünümünde - bir toplantı sırasında getirmek istediğim tüm kod inceleme yorumlarını göstereceğim.

Burada biraz daha şablon var .

İçerir:

• Belirli bir tarihten bir tarih nesnesi oluşturma
• Yeni bir genel ArrayList oluşturun
• Kaydedici kurulumu
• Belirtilen seviyeye sahip günlük
• Yeni bir genel HashMap oluşturma
• Bir harita üzerinden yineleme yapın, anahtarları ve değerleri yazdırın
• SimpleDateFormat kullanarak bir zamanı ayrıştırın
• Dosyayı satır satır okuma
• Yakalanan bir muafiyeti günlüğe kaydet ve yeniden
• Bir kod bloğunun yürütme süresini yazdır
• Periyodik Zamanlayıcı Oluştur
• Dosyaya Dize Yazma

slf4j Günlüğe Kaydetme

${imp:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}

private static final Logger LOGGER = LoggerFactory
    .getLogger(${enclosing_type}.class);

Fasulye Özelliği

private ${Type} ${property};

public ${Type} get${Property}() {
    return ${property};
}

public void set${Property}(${Type} ${property}) {
    ${propertyChangeSupport}.firePropertyChange("${property}", this.${property},     this.${property} = ${property});
}

PropertyChangeSupport

private PropertyChangeSupport ${propertyChangeSupport} = new PropertyChangeSupport(this);${:import(java.beans.PropertyChangeSupport,java.beans.PropertyChangeListener)}
public void addPropertyChangeListener(PropertyChangeListener listener) {
  ${propertyChangeSupport}.addPropertyChangeListener(listener);
}

public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
  ${propertyChangeSupport}.addPropertyChangeListener(propertyName, listener);
}

public void removePropertyChangeListener(PropertyChangeListener listener) {
  ${propertyChangeSupport}.removePropertyChangeListener(listener);
}

public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
  ${propertyChangeSupport}.removePropertyChangeListener(propertyName, listener);
}

Java 7'den sonra, çevreleme sınıfına statik başvuru gerektiren (veya tercih eden) günlükçüler oluşturmanın harika bir yolu, çalışma zamanı sınıfını statik bir bağlamda elde etmek için yeni tanıtılan MethodHandles API'sini kullanmaktır.

SLF4J için örnek bir pasaj:

private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

Herhangi bir IDE'de basit bir snippet olmasının yanı sıra, belirli işlevselliği başka bir sınıfa yeniden yansıtmanız da daha az kırılgandır, çünkü sınıf adını yanlışlıkla onunla taşımazsınız.

GUI iş parçacığında kodu çağır

slaterGUI iş parçacığında kodu hızla göndermek için aşağıdaki şablonu kısayola bağlarım.

${:import(javax.swing.SwingUtilities)}
SwingUtilities.invokeLater(new Runnable() {      
      @Override
      public void run() {
        ${cursor}
      }
    });

Kod ile test ederken bazen bazı syso s silmek için kaçırmış . Bu yüzden kendime syt adlı bir şablon yaptım .

System.out.println(${word_selection}${});//${todo}:remove${cursor}

Derlemeden önce her zaman TODO'larımı kontrol ediyorum ve bir System.out dosyasını tekrar silmeyi asla unutmayacağım.

strf -> String.format("msg", args) oldukça basit ama yazarak biraz tasarruf sağlar.

String.format("${cursor}",)

Mevcut ekrandan bir SWT rengi elde edin:

Display.getCurrent().getSystemColor(SWT.COLOR_${cursor})

Syncexec özellikli ortam

PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable(){
    public void run(){
        ${line_selection}${cursor}
    }
});

Singleton tasarım desenini kullanın:

/**
 * The shared instance.
 */
private static ${enclosing_type} instance = new ${enclosing_type}();

/**
 * Private constructor.
 */
private ${enclosing_type}() {
    super();
}

/**
 * Returns this shared instance.
 *
 * @returns The shared instance
 */
public static ${enclosing_type} getInstance() {
    return instance;
}

Ve bir eşit oluşturucu, hashcodebuilder uyarlaması:

${:import(org.apache.commons.lang.builder.EqualsBuilder,org.apache.commons.lang.builder.HashCodeBuilder)}
@Override
public boolean equals(Object obj) {
    return EqualsBuilder.reflectionEquals(this, obj);
}

@Override
public int hashCode() {
    return HashCodeBuilder.reflectionHashCode(this);
}

Kaydedici beyanı şablonu harika.

Ayrıca daha sık kullandığım günlük düzeyleri için linfo, ldebug, lwarn, lerror oluşturuyorum.

lerror:

logger.error(${word_selection}${});${cursor}

Bir etkinlik için her şeyi oluşturun

Olaylar Java'da yaratmak için bir acı olduğundan - sadece 1 olay için yazmak için tüm bu arayüzler, yöntemler ve şeyler - 1 olay için gereken her şeyi oluşturmak için basit bir şablon yaptım.

${:import(java.util.List, java.util.LinkedList, java.util.EventListener, java.util.EventObject)}

private final List<${eventname}Listener> ${eventname}Listeners = new LinkedList<${eventname}Listener>();

public final void add${eventname}Listener(${eventname}Listener listener)
{
    synchronized(${eventname}Listeners) {
        ${eventname}Listeners.add(listener);
    }
}

public final void remove${eventname}Listener(${eventname}Listener listener)
{
    synchronized(${eventname}Listeners) {
        ${eventname}Listeners.remove(listener);
    }
}

private void raise${eventname}Event(${eventname}Args args)
{
    synchronized(${eventname}Listeners) {
        for(${eventname}Listener listener : ${eventname}Listeners)
            listener.on${eventname}(args);
    }
}

public interface ${eventname}Listener extends EventListener
{
    public void on${eventname}(${eventname}Args args);
}

public class ${eventname}Args extends EventObject
{
    public ${eventname}Args(Object source${cursor})
    {
        super(source);
    }
}

Tek bir paylaşan etkinlikleriniz varsa EventObject, sadece şablon tarafından eklenen özelleştirilmiş birini silin ve uygun bölümlerini değiştirmek raise___()ve on____().

Genel bir arayüz ve genel sınıf kullanarak güzel, küçük, zarif bir olay mekanizması yazmıştım, ancak Java'nın jenerikleri işleme biçimi nedeniyle işe yaramazdı. = (

Düzenleme : 1) Ben bir olay gerçekleşirken iş parçacığı ekleyerek / dinleyici kaldırma sorunu içine koştu. Kullanım Listsırasında değiştirilemez, bu yüzden synchronizeddinleyicilerin listesine erişildiği veya kullanıldığı blokları listeye kilitledim.

Insert test yöntemleri ne zaman verilmelidir

Çok iyi bir geliştirici ve arkadaş ile çift programlama yaparken son zamanlarda buna benzer bir sürüm gördüm ve bence bu listeye güzel bir ek olabilir.

Bu şablon , kodun yapılandırılması için bir kılavuz olarak, yorumlardaki davranış odaklı geliştirme (BDD) paradigmasından verilen - Ne Zaman - Sonra yaklaşımını izleyerek sınıfta yeni bir test yöntemi oluşturur . Yöntem adını "must" ile başlatacak ve "CheckThisAndThat" kukla yöntem adının geri kalanını test yöntemi sorumluluğunun mümkün olan en iyi açıklamasıyla değiştirmenize izin verecektir. Adı doldurduktan sonra, SEKME sizi doğrudan adresine götürür , böylece ön koşullarınızı yazmaya başlayabilirsiniz.// Given section

Ben üç "tst", "Test yöntemleri-zaman-sonra-gerekir";) açıklaması ile eşleştirilmiş var;)

Umarım gördüğümde yaptığım kadar faydalı bulursunuz:

@Test
public void should${CheckThisAndThat}() {
    Assert.fail("Not yet implemented");
    // Given
    ${cursor}

    // When


    // Then

}${:import(org.junit.Test, org.junit.Assert)}

Yay Enjeksiyonu

Bunun oyunun biraz geç olduğunu biliyorum, ama burada bir sınıfta Bahar Enjeksiyonu için kullandığım bir şey:

${:import(org.springframework.beans.factory.annotation.Autowired)}
private ${class_to_inject} ${var_name};

@Autowired
public void set${class_to_inject}(${class_to_inject} ${var_name}) {
  this.${var_name} = ${var_name};
}

public ${class_to_inject} get${class_to_inject}() {
  return this.${var_name};
}

İşte somut olmayan sınıflar için bir kurucu:

// Suppress default constructor for noninstantiability
@SuppressWarnings("unused")
private ${enclosing_type}() {
    throw new AssertionError();
}

Bu özel istisnalar içindir:

/**
 * ${cursor}TODO Auto-generated Exception
 */
public class ${Name}Exception extends Exception {
    /**
     * TODO Auto-generated Default Serial Version UID
     */
    private static final long serialVersionUID = 1L;    

    /**
     * @see Exception#Exception()
     */
    public ${Name}Exception() {
        super();
    }

    /**
     * @see Exception#Exception(String) 
     */
    public ${Name}Exception(String message) {
        super(message);         
    }

    /**
     * @see Exception#Exception(Throwable)
     */
    public ${Name}Exception(Throwable cause) {
        super(cause);           
    }

    /**
     * @see Exception#Exception(String, Throwable)
     */
    public ${Name}Exception(String message, Throwable cause) {
        super(message, cause);
    }
}

Ben böyle bir oluşturulan sınıf yorumu gibi:

/**
 * I... 
 * 
 * $Id$
 */

"Ben ..." derhal geliştiriciyi sınıfın ne yaptığını anlatmaya teşvik eder. Belgelenmemiş sınıflar sorununu iyileştiriyor gibi görünüyorum.

Ve elbette $ Id $ yararlı bir CVS anahtar kelimesidir.

Bu snippet'leri çok fazla kullandım, nulldeğerler ve boş dizeler arıyorum .

Alınan argümanları kontrol etmek için yöntemlerimdeki ilk kod olarak "argüman test" -templates kullanıyorum.

testNullArgument

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}

İstisna mesajını şirketinizin veya projenizin standardına uyacak şekilde değiştirmek isteyebilirsiniz. Ancak, rahatsız edici argümanın adını içeren bir mesaj almanızı öneririm. Aksi takdirde, yönteminizin arayanı neyin yanlış gittiğini anlamak için koda bakmalıdır. ( NullPointerExceptionİletisi olmayan A , oldukça saçma "null" iletisiyle bir istisna oluşturur).

testNullOrEmptyStringArgument

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}
${varName} = ${varName}.trim();
if (${varName}.isEmpty()) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument cannot be an empty string: ${varName}");
}

Ayrıca boş denetim şablonunu yukarıdan tekrar kullanabilir ve bu parçacığı yalnızca boş dizeleri denetlemek için uygulayabilirsiniz. Daha sonra yukarıdaki kodu üretmek için bu iki şablonu kullanırsınız.

Bununla birlikte, yukarıdaki şablonda, argümanda son ise, üretilen kodu bazılarını değiştirmeniz ${varName} = ${varName}.trim()gerekecektir (başarısız olacaktır).

Çok sayıda son argüman kullanıyorsanız ve boş dizeleri kontrol etmek istiyorsanız, ancak bunları kodunuzun bir parçası olarak kırpmanız gerekmiyorsa, bununla devam edebilirsiniz:

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}
if (${varName}.trim().isEmpty()) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument cannot be an empty string: ${varName}");
}

testNullFieldState

Ayrıca, bağımsız değişken olarak gönderilmeyen değişkenleri kontrol etmek için bazı snippet'ler oluşturdum (büyük fark, istisna tipidir, şimdi IllegalStateExceptionbunun yerine).

if (${varName} == null) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field cannot be null: ${varName}");
}

testNullOrEmptyStringFieldState

if (${varName} == null) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field cannot be null: ${varName}");
}
${varName} = ${varName}.trim();
if (${varName}.isEmpty()) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field " +
            "cannot be an empty string: ${varName}");
}

testArgument

Bu, bir değişkeni test etmek için genel bir şablondur. Bunu takdir etmeyi öğrenmek birkaç yılımı aldı, şimdi çok kullanıyorum (elbette yukarıdaki şablonlarla birlikte!)

if (!(${varName} ${testExpression})) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument ${varName} (" + ${varName} + ") " +
        "did not pass the test: ${varName} ${testExpression}");
}

Bir değişken adı veya değer döndüren bir koşulu, ardından bir işlenen ("==", "<", ">" vb.) Ve başka bir değer veya değişken girersiniz ve sınama başarısız olursa, sonuçta ortaya çıkan kod bir IllegalArgumentException oluşturur.

Tüm ifadenin bir "! ()" İçine sarılmasıyla biraz karmaşık if yantümcesinin nedeni, istisna mesajındaki test koşulunun yeniden kullanılmasını mümkün kılmaktır.

Belki de bir meslektaşı karıştıracaktır, ancak sadece bu tür istisnaları atarsanız koda bakmayacakları koda bakmaları gerekiyorsa ...

İşte dizilerle ilgili bir örnek:

public void copy(String[] from, String[] to) {
    if (!(from.length == to.length)) {
        throw new IllegalArgumentException(
                "Illegal argument. The argument from.length (" +
                            from.length + ") " +
                "did not pass the test: from.length == to.length");
    }
}

Bu sonucu, "from.length" [TAB] "== to.length" yazarak şablonu çağırarak elde edersiniz.

Sonuç, "ArrayIndexOutOfBoundsException" veya benzerlerinden çok daha komiktir ve kullanıcılarınıza sorunu çözme şansı verebilir.

Zevk almak!

MessageFormat (Java 1.4 kullanarak) için bunu kullanın. Bu şekilde, uluslararasılaşma yaparken elde edilmesi zor hiçbir birleşim olmadığından eminim

i18n

String msg = "${message}";
Object[] params = {${params}};
MessageFormat.format(msg, params);

Ayrıca kayıt için:

günlük

if(logger.isDebugEnabled()){
  String msg = "${message}"; //NLS-1
  Object[] params = {${params}};
  logger.debug(MessageFormat.format(msg, params));
}

En sevdiğim birkaç ...

1: Javadoc, Spring nesnesi enjeksiyon yöntemi olma yöntemiyle ilgili dokümanı eklemek için.

 Method to set the <code>I${enclosing_type}</code> implementation that this class will use.
* 
* @param ${enclosing_method_arguments}<code>I${enclosing_type}</code> instance 

2: Bir FileOutputStream oluşturmak ve arabellek içeriğini bir dosyaya yazmak için hata ayıklama penceresi. Bir arabelleği geçmiş bir çalışma ile karşılaştırmak istediğinizde (BeyondCompare kullanarak) veya çok büyük olduğundan bir arabellek içeriğini (denetleme yoluyla) görüntüleyemiyorsanız ...

java.io.FileOutputStream fos = new java.io.FileOutputStream( new java.io.File("c:\\x.x"));
fos.write(buffer.toString().getBytes());
fos.flush();
fos.close();