Witam. Mam następujący problem. Mam zapisaną macierz w pliku txt. Format zapisu to:
232 123 322
243 423 543
245 123 432
Chciałbym zamienić miejscami elementy tak żeby wyglądała następująco:
432 123 245
345 423 243
322 123 232
Ma ktoś jakiś pomysł?
int[][] outMatrix = new int[oldSize][oldSize];
for(int i = 0; i < oldSize; i++)
for(int o = 0; o < oldSize; o++)
outMatrix[o][i] = inMatrix[i][o];
Eee... Stworzyć dwuwymiarową tablicę int 3x3 komórki, wczytać z pliku i pozamieniać? Np. jeżeli wiesz, że macierz jest 3x3
public static void switchTables(int[][] table){
int buff;
for(int i=0; i<3; i++){
buff = table[0][i];
table[0][i] = table[2][2-i];
table[2][2-i] = buff;
}
buff = table[1][0];
table[1][0] = table[1][2];
table[1][2] = buff;
}
A po co dwie tablice? Przecież nie ma obowiązku, żeby odczytane liczby wpisywać do kolejnych wierszy tablicy, można ją wypełniać od końca.
A ma ktoś pomysł jak wczytać tą macierz do tablicy? Chciałbym żeby każda liczba była osobnym elementem tablicy. Wykombinowałem coś takiego ale zwraca mi dziwny wynik.
while ((line = bfr.readLine()) != null) {
String[] row = line.split(" ");
rows.add(row);
}
System.out.println(rows.toString());
Wydaje mi się, ze powinienem utworzyć tablice dwuwymiarową żeby zapisywać w niej pozycje elementu, ale nie wiem czy to dobry trop.
Nie piszesz czy znasz ilość wierszy w pliku, czy wiesz ile jest liczb w każdym wierszu i czy w każdym wierszu jest tyle samo liczb. Poniższy kod zakłada, że "niczego" nie wiesz. Jeśli coś wiesz, to kod można uprościć.
<code=java.
ArrayList<int []> rows=new ArrayList<int []>(); //bo nie wiadomo ile będzie wierszy
while ((line = bfr.readLine()) != null)
{
String[] row = line.split(" ");
int[] numbersInRow=new int[row.length];
for(int i=0;i<row.length;i++)
{
numbersInRow[i]=Integer.parseInt(row[i]);
}
rows.add(NumbersInRow);
}
int[][] result=new int[rows.size()][];
result=wiersze.toArray(result); //konwersja na tablicę dwuwymiarową
Moje problemy rozwiązałem w troszkę inny sposób, lecz pojawił się kolejny. Wczytuje z pliku macierz wyglądającą tak:
321 232 121
323 123 423
423 123 124
a dostaje wynik:
124? 123 423
423 123 323
121 232 321
Nie mam pojęcia dlaczego przy liczbie 124 pokazuje mi dodatkowo "?" Oto kod aplikacji:
public class filess {
public static void main(String args[]) throws IOException {
int i;
FileInputStream fin;
try {
fin = new FileInputStream("C:/mac.txt");
} catch(FileNotFoundException exc) {
System.out.println("File Not Found");
return;
} catch(ArrayIndexOutOfBoundsException exc) {
System.out.println("Usage: ShowFile File");
return;
}
String s = "";
do {
i = fin.read();
s += (char) i;
} while(i != -1);
fin.close();
StringTokenizer n = new StringTokenizer(s);
String [] arr = new String[9];
int nn = 0;
while(n.hasMoreTokens()){
arr[nn] = n.nextToken();
nn+=1;
}
for(int iii = 8; iii >=0 ; iii--){
System.out.print(arr[iii] + " ");
if(((iii)%3)== 0) {
System.out.println();
}
}
}
}
ma ktoś jakiś pomysł?
Do tego służy programowanie obiektowe by nie pisać tych wszystkich popieprzonych pętli. Serio. Jak już piszesz w Javie to nikt nie będzie narzekał na takie coś:
class Row {
private int[] row;
public Row(int[] row) {
this.row = row;
}
public void reverse() {
int reversed[] = new int[row.length];
for (int i = 0, j = row.length - 1; i < row.length; i++, j--) {
reversed[j] = row[i];
}
row = reversed;
}
@Override
public String toString() {
return Arrays.toString(row);
}
}
takie samo coś dla Array2d:
class Array2D {
private Row[] rows;
public Array2D(Row[] row) {
this.rows = row;
}
public void reverse() {
Row reversed[] = new Row[rows.length];
for (int i = 0, j = rows.length - 1; i < rows.length; i++, j--) {
reversed[j] = rows[i];
reversed[j].reverse();
}
rows = reversed;
}
@Override
public String toString() {
return Arrays.toString(rows);
}
}
i w ramach testu:
public class App {
private static BufferedReader reader;
public static void main(String[] args) throws Exception {
Row r1 = new Row(new int[] { 232, 123, 322 });
Row r2 = new Row(new int[] { 243 ,423 ,543 });
Row r3 = new Row(new int[] { 245 ,123 ,432 });
Array2D a = new Array2D(new Row[]{r1, r2, r3});
System.out.println(a);
a.reverse();
System.out.println(a);
}
}
Elegancko, obiektowo, a w dodatku można to jeszcze przerobić na genericsy i nie trzeba kombinować z zagnieżdżaniem pętli.
Rozwiązanie super. Tylko wtedy gdy mamy na sztywno wpisane dane. Ja dane chce wczytywać z pliku txt, a to dlatego, że tablica będzie wymiaru 100x100. Dlatego zastanawiam się jak to pieroństwo wczytać.
s.append(char (i));
taki kod może być kilkaset razy szybszy od Twojego, a przy bardzo dużych plikach, to nawet kilkanaście tysięcy razy szybszy.
@bo w Twoim kodzie jest coś nie tak w linii numbersInRow[i]=Integer.parseInt(row[i]); Być może przez niedokończoną pętle for.
Do klasy Row można dodać metodę fabrykującą fromString(String):
public static Row fromString(String rowAsString){
String[] numbersAsString = rowAsString.trim().split(" ");
int[] numbers = new int(numbersAsString.length);
for(int i =0; i< numbersAsString.length; i++){
numbers[i] = Integer.parseInt(numbersAsString[i]);
}
return new Row(numbers);
}
Wystarczy wczytywać linie jakimś readerem z readLine() i tyle. To samo można zrobić dla tablicy. W dodatku jeżeli możesz skorzystać z Javy 7 to masz Files.readAllLines, które wczytuje wszystkie linie z pliku do List<String>.
Sorry, .
ArrayList<int[]> rows=new ArrayList<int[]>(); //bo nie wiadomo ile będzie wierszy
while ((line = bfr.readLine()) != null)
{
String[] row = line.split(" ");
int[] numbersInRow=new int[row.length];
for(int i=0;i<row.length;i++)
{
numbersInRow[i]=Integer.parseInt(row[i]);
}
rows.add(NumbersInRow);
}
int[][] result=new int[rows.size()][];
result=wiersze.toArray(result); //konwersja na tablicę dwuwymiarową
Ten kod tworzy dwuwymiarową tablicę liczb. Nie wiem co masz robić z tą tablicą, Twój ostatni kod sugeruje, że nie potrzebujesz w ogóle liczb. Uproszczona wersja bez konwersji na liczby.
ArrayList<String[]> rows=new ArrayList<String[]>(); //bo nie wiadomo ile będzie wierszy
while ((line = bfr.readLine()) != null)
{
rows.add(line.split(" "));
}
String[][] result=new String[rows.size()][];
result=wiersze.toArray(result); //konwersja na tablicę dwuwymiarową
a jak się ma wczytywanie danych zapisanych binarnie. Ten sam schemat, dane zapisane jako 2 bajtowe inty. Czy schemat wczytywania jest ten sam?
Schemat będzie taki sam. Inaczej będzie trzeba je tylko interpretować. No i najważniejsze czytasz za pomocą ByteArrayInputStream.