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));
}
}
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).
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?
}
}
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ść.
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.
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());
}
Dziękuję bardzo za pomoc.