odczytywanie wymiarow tablicy z pliku

0

Witam, jestem poczatkujacym programistą i nie wiem, jak "wyłuskać" do zmiennej wymiary tablicy (konkretnie liczbe jej wierszy) wczytanej z pliku. Podaje fragment kodu. Wiem, że prawdopodobnie moj problem jest banalny, ale dopiero zaczynam przygode z programowaniem, totez bede wdzieczny za każdą wskazówkę
public void aaaaa1() {
Scanner s = new Scanner(new File("data.txt"));
final Pattern SEP = Pattern.compile("\s+");
while(s.hasNextLine()){
String line = s.nextLine();
String[] tab = SEP.split(line);
String[] row = new String[tab.length];
for(int i=0;i<tab.length;i++)
row[i]=tab[i];
System.out.println(Arrays.toString(row));
}
}

0

Nie wiem czy dobrze rozumiem. Czytasz plik i chcesz by każdy wiersz pliku utworzył element tablicy? Jeśli tak, to zmień koncepcję, zamiast tablicy utwórz kolekcję (np. ArrayList).

0

Chce uzyskać tablicę stringow, tak aby moc sie odwolywac do poszczegolnych elementow tej tablicy (pojedynczych liter) :
import java.io.File;
import java.util.Arrays;
import java.util.Scanner;
import java.util.regex.Pattern;

class aaaaa1 {
public static void main(String[] args) throws Exception {
Scanner s = new Scanner(new File("data.txt"));
final Pattern SEP = Pattern.compile("\s+");
int x=0;
while(s.hasNextLine()){
String line = s.nextLine();
String[] tab = SEP.split(line);
String[] row = new String[tab.length];

               for(int i=0;i<tab.length;i++)
               
            	   row[i]=tab[i];
               x+=1;
               System.out.println(Arrays.toString(row));
                                
            }
            System.out.println(x); \\ dobrze rozumiem, ze wymiarami tablicy sa tab.length i wartosc zmiennej x? 
            
    }

}

0

Po pierwsze, ten fragment jest raczej bez sensu

   String[] tab = SEP.split(line);
   String[] row = new String[tab.length];
   for(int i=0;i<tab.length;i++)
       row[i]=tab[i];
   x+=1;

Po co Ci dwie tablice z identyczną zawartością?
Po drugie, po zakończeniu pętli nie masz żadnej tablicy, zatem nie potrzebujesz się martwić jaką ta tablica ma długość.

0

Mam taki problem: chcę przeksztalcic nastepujacy kod w taki sposob, aby pobieral dane do gry z pliku, a nie generowal go wczesniej.

import java.io.File;
import java.util.Arrays;
import java.util.Scanner;
import java.util.regex.Pattern;

class GraWZycie {
// pola przechowujące rozmiar naszej planszy
int poziomo, pionowo;
// stałe symbolizujące żywą i martwą komórkę
boolean[][] tablica;
char zywa = 'o';
char martwa = 'm';
// deklaracja macierzy z planszą gry

// konstruktor, podajemy liczbę wierszy i kolumn planszy

}
public class gra_w_zycie extends GraWZycie
{
public gra_w_zycie(int poziomo, int pionowo) {
// inicjalizujemy pola naszej klasy
this.pionowo = pionowo;
this.poziomo = poziomo;

	// tworzymy odpowiednią macierz, domyślnie wypełniona jest ona wartościami false
	//tablica = new boolean[poziomo][pionowo];
	}
/* to jest moja nieudolna proba przeksztalcenia go, niestety nie wiem co dalej: public void aaaaa1() throws Exception {
    Scanner s = new Scanner(new File("data.txt"));
    final Pattern SEP = Pattern.compile("\\s+");
    int x=0;
    while(s.hasNextLine()){
       String line = s.nextLine();      
       String[] tab = SEP.split(line);
       String[] row = new String[tab.length];
       for(int i=0;i<tab.length;i++)
               row[i]=tab[i];
       x+=1;
       int z=tab.length;
       System.out.println(Arrays.toString(row));      
       for (int i = 0; i < row.length; i++)
       {
        for (int j = 0; j < x; j++)
        {
        System.out.print(tab[j]);
         }
       } 
           }
  
    
    }

}
/*
// metoda pokazująca planszę na ekranie
//public void pokazPlansze(){
// wyświetlamy każdy element planszy, w zależności od zawartości na ekranie pojawi się odpowiedni znak
//for(boolean wiersz[] : tablica){
//for(boolean element : wiersz)
//System.out.print((element) ? zywa : martwa);
//System.out.println();
//}
//}

// przykładowa metoda uzupełniająca planszę populacją początkową
//public void utworzDaneTestowe() {
// tworzymy populację początkową (standardowy Exploder)
//tablica[5][5] = true; tablica[5][7] = true; tablica[5][9] = true;
//tablica[6][5] = true; tablica[6][9] = true;
//tablica[7][5] = true; tablica[7][9] = true;
//tablica[8][5] = true; tablica[8][9] = true;
//tablica[9][5] = true; tablica[9][7] = true; tablica[9][9] = true;
//}

// metoda zwraca liczbę żywych sąsiadów konkretnej komórki
// w wywołaniu podajemy współrzędne komórki
int liczbaSasiadow(int x, int y) {

// zmienna przechowująca liczbę sąsiadów
int sasiedzi = 0;

// sprawdzamy komórki na około naszej
for(int i = x-1; i <= x+1; i++) {
// jeżeli przekraczamy zakres planszy (wiersz) idziemy dalej
if(i < 0 || i > poziomo-1) continue;
for(int j = y-1; j <= y+1; j++) {
// jeżeli przekraczamy zakres planszy (kolumna), lub jesteśmy w komórce(x,y) idziemy dalej
if(j < 0 || j > pionowo-1 || (i == x && j == y)) continue;
// jeśli sąsiad jest żywy to zwiększamy naszą zmienną
if(tablica[i][j]) sasiedzi++;
}
}
// zwracamy zmienną
return sasiedzi;
}

// metoda sprawdza czy dana komórka będzie żywa czy też martwa w następnym etapie
// w wywołaniu podajemy współrzędne komórki
boolean ewolucja(int x, int y) {

// sprawdzamy liczbę żywych sąsiadów
int sasiedzi = liczbaSasiadow(x, y);

// jeżeli nasza komórka jest żywa
if(tablica[x][y]) {
// jeśli liczba sąsiadów jest mniejsza lub równa jeden lub większa od trzech to nasza komórka będzie martwa
if(sasiedzi <= 1 || sasiedzi > 3) return false;
// jeśli liczba sąsiadów jest równa trzy lub dwa to nasza komórka będzie żywa
if(sasiedzi == 3 || sasiedzi == 2) return true;
} else {
// jeśli nasza komórka jest martwa i ma dokładnie trzech żywych sąsiadów to będzie żyła
if(sasiedzi == 3) return true;
}
// w każdym innym przypadku zwracamy fałsz (komórka jest martwa)
return false;
}

// metoda tworzy następną populację/pokolenie komórek
public void nastepnePokolenie() {
// tworzymy planszę tymczasową o takim samy rozmiarze jak nasza
boolean[][] tablicaTymczasowa = new boolean[poziomo][pionowo];

// uzupełniamy nową planszę wartościami na podstawie ogólnych zasad
for(int i = 0; i < poziomo; i++)
for(int j = 0; j < pionowo; j++)
tablicaTymczasowa[i][j] = ewolucja(i, j);

// nasza główna tablica staje się planszą tymczasową
tablica = tablicaTymczasowa;
}

public static void main(String[] args) {

// wyświetlamy napisy informacyjne
System.out.println("Gra w życie - [Enter] generuje następne pokolenie, dowolny znak i [Enter] kończy grę.");

// obsługujemy wejście
Scanner sc = new Scanner(System.in);

// tworzymy nowy obiekt przekazując do konstruktora rozmiar planszy
gra_w_zycie gra = new gra_w_zycie(15, 15);
// wypełniamy naszą planszę wartościami testowymi
gra.utworzDaneTestowe();
// wyświetlamy planszę na ekranie
gra.pokazPlansze();

// dopóki użytkownik będzie naciskał klawisz Enter
while(sc.nextLine().equals("")) {
// generujemy następne pokolenie
gra.nastepnePokolenie();
// wyświetlamy go na ekranie
gra.pokazPlansze();
}
}
}
Wiem, ze nie powinienem prosic o gotowe rozwiazanie, ale probowalem sam, niestety moj obecny stan wiedzy nie pozwala na samodzielne dojscie do rozwiazania. Będę bardzo wdzieczny za pomoc.

0

Przykładowe rozwiązanie, zakładam, że wszystkie wiersze zawierają taką treść: m o o m o ... m

ArrayList<boolean[]> wiersze = new ArrayList<boolean[]>();
try
{
   Scanner s=new Scanner(new File("data.txt"));
   while(s.hasNextLine())
   {
       String line=s.nextLine();
       String[] items=line.split(" ");
       boolean[] cells=new boolean[items.length];
       for(int i=0;i<items.length;i++)
       {
           cells[i]=(items[i].equals("o"))?true:false;
       }
       wiersze.add(cells);
   }
   tablica=new boolean[wiersze.size()][];
   for(int i=0;i<wiersze.size();i++)
   {
       tablica[i]=wiersze.get(i);
   }   
}
catch(FileNotFoundException e)
{
   System.out.println(e.getMessage());
}
0

Dziękuję bardzo za pomoc.

1 użytkowników online, w tym zalogowanych: 0, gości: 1