JTable – zmiana kolejności kolumn
Przydatna metoda pozwalająca zmienić kolejność kolumn w tabeli w podstawie ich identyfikatorów
import javax.swing.JTable;
import javax.swing.table.TableColumnModel;
public class TableUtils {
/**
* Zmienia kolejność kolumn w tabeli
*/
public static void reorderColumns(JTable table, Object... columnIdentifiers) {
TableColumnModel model = table.getColumnModel();
for (int newIndex = 0; newIndex < columnIdentifiers.length; newIndex++) {
try {
Object columnIdentifier = columnIdentifiers[newIndex];
int oldIndex = model.getColumnIndex(columnIdentifier);
model.moveColumn(oldIndex, newIndex);
} catch (IllegalArgumentException e) {
// Identyfikator kolumny jest null lub nie istnieje kolumna o
// podanym identyfikatorze. W obu przypadkach, po prostu
// przechodzimy dalej
}
}
}
}
[JRuby] Gemy ruby-debug i ruby-debug-ide w JRuby
Miło mi poinformować, że cała konfiguracja niezbędna do debugowania aplikacji w JRuby on Rails sprowadza się (nareszcie!) do instalacji dwóch gemów
jruby -S gem install ruby-debug jruby -S gem install ruby-debug-ide
JRuby on Rails 3 + Embedded Derby w Windows 7
Instalujemy JDK i ustawiamy zmienną środowiskową JAVA_HOME
setx JAVA_HOME "\path\to\jdk"
Pobieramy świeżą wersję JRuby, rozpakowujemy i ustawiamy zmienną środowiskową
JRUBY_HOMEsetx JRUBY_HOME "\path\to\jruby"
Pobieramy Derby, rozpakowujemy i ustawiamy zmienną
DERBY_HOMEsetx DERBY_HOME "\path\to\derby"
Technicznie rzecz biorąc, instalacja Derby nie jest konieczna, bo wymagane archiwum jar zostanie pobrane przy instalacji gem’a activerecord-jdbcderby-adapter – ale i tak warto to zrobić ze względu na przydatne narzędzia jakie dostajemy wraz z normalną instalacją Derby.
Restartujemy wiersz poleceń i dodajemy katalogi %JAVA_HOME%\bin,%DERBY_HOME%\bin i %JRUBY_HOME%\bin do zmiennej PATH
setx PATH "%PATH%;%JAVA_HOME%\bin;%DERBY_HOME%\bin;%JRUBY_HOME%\bin"
Instalujemy Rails
jruby -S gem install rails
Instalujemy gem ActiveRecord-JDBC dla Derby
jruby -S gem install activerecord-jdbcderby-adapter
Zastosowanie opcji przy instalacji opcji
--no-rdoc --no-ri znacząco ją przyśpieszy kosztem dokumentacji.
I w zasadzie możemy już rozpocząć pracę z JRuby On Rails 3 
.
Po wygenerowaniu aplikacji, wystarczy tylko zmodyfikować plik database.xml
development: adapter: derby database: db/development.db test: adapter: derby database: db/test.db production: adapter: derby database: db/production.db
i zamienić adapter JDBC z
'activerecord-jdbc-adapter'
na specyficzny dla Derby
'activerecord-jdbcderby-adapter'
Co oznacza, ze plik Gemfile powinien wyglądać następująco
source 'http://rubygems.org' gem 'rails', '3.0.9' # Bundle edge Rails instead: # gem 'rails', :git => 'git://github.com/rails/rails.git' platforms :ruby do gem 'sqlite3' end platforms :jruby do gem 'activerecord-jdbcderby-adapter' end
Gotowe! Pora na test
cd myapp jruby -S script/rails server
[Java] Wczytywanie danych ze strumienia wejścia do tablicy
Odczyt danych ze strumienia wejścia i zapis do tablicy bajtów
package jp.util;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* <p>
* Metody narzędziowe dla strumieni
* </p>
*
* @author Jarek Przygódzki
*
*/
public class Stream {
/**
* Odczytuje wszystkie dane ze strumienia
*
* @param stream
* strumień do odczytu
* @param bufSize
* rozmiar bufora odczytu
* @return tablica odczytanych bajtów
* @throws IOException
* jeśli wyrzuci go strumień <code>stream</code>
*/
public static byte[] ReadAll(InputStream stream, int bufSize)
throws IOException {
ByteArrayOutputStream bs = new ByteArrayOutputStream(bufSize);
byte[] buf = new byte[bufSize];
int len;
while ((len = stream.read(buf)) > 0) {
bs.write(buf, 0, len);
}
/*
* W pełni świadomie nie opróżnieniamy bufora strumienia i nie zamykamy
* go. W przypadku ByteArrayOutputStream jest to zbędne.
*/
return bs.toByteArray();
}
}
[Java] java.io.ByteArrayOutputStream – dostęp do wewnętrznego bufora
Klasa java.io.ByteArrayOutputStream jest bardzo użyteczna. Czasem jednak chcielibyśmy uzyskać bezpośredni dostęp do wewnętrznego bufora a nie tworzyć jego kopię za pomocą ByteArrayOutputStream#toByteArray()
import java.io.ByteArrayOutputStream;
/**
* <p>
* Klasa rozszerza {@link java.io.BufferedOutputStream} umożliwiając dostęp do
* wewnętrznego bufora
* </p>
*
* @author Jarek Przygódzki
*
*/
public class AccessibleByteArrayOutputStream extends ByteArrayOutputStream {
public AccessibleByteArrayOutputStream(int size) {
super(size);
}
public AccessibleByteArrayOutputStream() {
super();
}
/**
* <p>
* Zwraca wewnętrzny bufor strumienia. Ważne - tylko pierwsze
* {@link AccessibleByteArrayOutputStream#size()} bajtów zawiera poprawne
* dane!
* </p>
*/
public byte[] getDataBuffer() {
return buf;
}
}
Dzięki temu możemy np. utworzyć strumień wejściowy bez zbędnego kopiowania
InputStream inputStream = new ByteArrayInputStream( outputStream.getDataBuffer(), 0 , outputStream.size());
[Java] Pobieranie wartości pola na podstawie nazwy
Pobieranie wartości pola klasy lub obiektu (egzemplarza klasy) z wykorzystaniem mechanizmu refleksji
import java.lang.reflect.Field;
/**
* @author Jarek Przygódzki
*/
public class FieldUtils {
@SuppressWarnings("unchecked")
public static <T> T getFieldValue(Class<?> cls, String fieldName, T defaultValue) {
T retValue = defaultValue;
try {
Field field = cls.getField(fieldName);
field.setAccessible(true);
retValue = (T) field.get(null);
} catch (SecurityException ignore) {
} catch (NoSuchFieldException ignore) {
} catch (IllegalArgumentException ignore) {
} catch (IllegalAccessException ignore) {
}
return retValue;
}
@SuppressWarnings("unchecked")
public static <T> T getFieldValue(Object obj, String fieldName, T defaultValue) {
T retValue = defaultValue;
Class<?> cls = obj.getClass();
try {
Field field = cls.getField(fieldName);
field.setAccessible(true);
retValue = (T) field.get(obj);
} catch (SecurityException ignore) {
} catch (NoSuchFieldException ignore) {
} catch (IllegalArgumentException ignore) {
} catch (IllegalAccessException ignore) {
}
return retValue;
}
}
[Java] Konwersja iteratora na wyliczenie
import java.util.Enumeration;
import java.util.Iterator;
/**
* @author Jarek Przygódzki
*/
public class En {
public static <T> Enumeration<T> wrap(final Iterator<T> it) {
return new Enumeration<T>() {
@Override
public boolean hasMoreElements() {
return it.hasNext();
}
@Override
public T nextElement() {
return it.next();
}
};
}
}
