3. TYPY DANYCH

1. Znaki i liczby

Typy pierwotne			Zawartość	Typy obiektowe
Nazwa	Liczba bitów	Zakres
boolean			true | false	Boolean
char	16		znak UNICODE	Character
byte	8	-128 ÷ 127	liczba całkowita ze znakiem
short	16	≈ ±3 × 10^4	liczba całkowita ze znakiem
int	32	≈ ±2 × 10^9	liczba całkowita ze znakiem	Integer
long	64	≈ ±9 × 10^18	liczba całkowita ze znakiem	Long
float	32		liczba rzeczywista ze znakiem	Float
double	64		liczba rzeczywista ze znakiem		Double

'A' pojedyńczy znak 12.34 stała typu double

'\n' nowy wiersz 12.34E5 stała typu double

12 stała typu int 12.34F stała typu float

12L stała typu long 12.3E2F stała typu float

Konwersje typów pierwotnych:

a) niejawna - w kierunku dokładniejszej reprezentacji liczb

int i = 1;

long a;

a = i;

b) jawna - w kierunku mniej dokładnej reprezentacji liczb

Przykład:

int i = 1000;

float f = 12.34;

byte b;

b = (byte) i; // wynik: -24

i = (int) f; // wynik: 12

Typy obiektowe (opakowania) służą do:

a) przechowywania stałych

MIN_VALUE, NEGATIVE_INFINITY NaN

MAX_VALUE POSITIVE_INFINITY

b) udostępniania pożytecznych metod, m.in.

static boolean Character.isLowerCase ( char z )

static boolean Character.isUpperCase ( char z )

static boolean Character.isDigit ( char z )

static boolean Character.isLetter ( char z )

Konwersji liczby typu pierwotnego na obiektowy dokonujemy za pomocą konstruktora, a do konwersji odwrotnej stosujemy metodę

• typValue ( ) >

Przykład:

int i = 5, j = 0;

System.out.println ( j ); // wynik 0

Integer ii = new Integer ( i ); // konstruktor Integer ( )

j = ii.intValue ( );

System.out.println ( j ); // wynik 5

boolean a = true, b = false;

System.out.println ( b ); // wynik false

Boolean aa = new Boolean ( a );

b = aa.booleanValue ( );

System.out.println ( b ); // wynik true

Znak zamieniamy na liczbę całkowitą za pomocą metody

Character.digit ( char znak, int podstawa )

a liczbę całkowitą na znak - za pomocą metody

Character.forDigit ( int liczba, int podstawa )

APLIKACJA TYPY

class Typy {

boolean bn;

char ch;

byte b;

short s;

static int i;

static long l;

static float f;

static double d;

final static String NAGŁÓWEK =
"APLIKACJA TYPY";

static void nagłówek ( ) {

…

}

public static void main ( String [ ] args ) {

Typy t = new Typy ( );

nagłówek ( );

// konwersja niejawna

i = 10; l = i;

System.out.println ( "l = " + l );

System.out.println ( "-----------" );

// konwersja jawna

d = 1234.56789;

f = ( float ) d;

l = ( long ) d;

i = ( int ) d;

t.s = ( short ) d;

t.b = ( byte ) d;

System.out.println ( "d = " + d );

System.out.println ( "f = " + f );

System.out.println ( "l = " + l );

System.out.println ( "i = " + i );

System.out.println ( "s = " + t.s );

System.out.println ( "b = " + t.b );

System.out.println ( "-----------" );

// konwersje znak->liczba i liczba->znak

t.ch = '5';

i = Character.digit ( t.ch, 10 );

System.out.println ( "i = " + i );

i = 6;

t.ch = Character.forDigit ( i, 10 );

System.out.println ( "ch = " + t.ch );

System.out.println ( "-----------" );

// sprawdzanie, czy znak jest liczbą

t.bn = Character.isDigit ( t.ch );

System.out.println ( t.bn );

}

}3.2. Napisy

Napis (łańcuch) jest obiektem klasy String. Instancje tej klasy można tworzyć w sposób standardowy

String s = new String("To jest napis");

lecz zwykle korzystamy z zapisu skróconego

String s = "To jest napis";

Napisy łączymy operatorem "+". W razie potrzeby, kompilator automa­tycz­nie dopasowuje typy:

int i = 12;

double a = 12.34;

System.out.println ( "i = " + i + " a = " + a );

Metody klasy String:

long	length ( )	zwraca długość napisu
char	charAt ( int i )	zwraca znak o indeksie i
int	indexOf ( char z )	zwraca indeks znaku z
int	indexOf ( String s )	zwraca indeks początku napisu s
boolean	s1.equals ( String s2 )	porównuje napisy s1 i s2
boolean	s1.regionMatches ( int start1, String s2, int start2, int length)	porównuje odcinek napisu s1 o długości length zaczynający się na pozycji start1 z odcinkiem napisu s2 o tej samej długości zaczynającym się na pozycji start2

Konwersji napisu na typ pierwotny dokonujemy za pomocą metod

Na typ	Z napisu
boolean	new Boolean ( tekst ).booleanValue ( )
int	Integer.parseInt ( tekst , int podstawa )
long	Long.parseLong ( tekst , int podstawa )
float	new Float ( tekst ).floatValue ( )
double	new Double ( tekst ).doubleValue ( )

Wartości typu pierwotnego zmieniamy na napisy metodą

• String.valueOf ( wartość );

APLIKACJA NAPISY

class Napisy {

static String s1 = "To jest napis";

static String s2 = "TO JEST NAPIS";

static String s3 = "Ten napis";

final static String NAGŁÓWEK = "APLIKACJA NAPISY";

static void nagłówek ( ) {

…

}

public static void main ( String [ ] args ) {

nagłówek ( );

// metody klasy String

System.out.println ("Napis s1 = " + s1 );

System.out.println ("Liczba znakow = " +
s1.length ( ) );

System.out.println ("Czwarty znak = " +
s1.charAt ( 4 ) );

System.out.println ("Indeks znaku 'e' = " +
s1.indexOf ( 'e' ) );

System.out.println ("Indeks poczatku slowa 'jest' = " + s1.indexOf ( "jest" ) );

System.out.println ("-----------------");

System.out.println ("Napis s1 = " + s1 );

System.out.println ("Napis s2 = " + s2 );

System.out.println ("Napis s3 = " + s3 );

System.out.println ("Porownanie napisow s1 i s2 = " + s1.equals ( s2 ) );

System.out.println ("Porownanie czesci napisow s1 i s3 = " + s1.regionMatches ( 8, s3, 4, 5 ) );

System.out.println ("-----------------");

// konwersja napis->liczba

boolean b = new Boolean ("true").booleanValue ( );

int i = Integer.parseInt ("123", 10 );

long a = Long.parseLong ("100000", 10 );

float f = new Float ("3.14F").floatValue ( );

double d = new Double ("123.456").doubleValue ( );

System.out.println ("b = " + b +"; i = " + i +
"; a = " + a + "; f = " + f + "; d = " + d );

System.out.println ("-----------------");

// konwersja liczba->napis

String sb = String.valueOf ( true );

String si = String.valueOf ( 123 );

String sa = String.valueOf ( 100000L );

String sf = String.valueOf ( 3.14F );

String sd = String.valueOf ( 123.456 );

System.out.println ("sb = " + sb + "; si = " + si +
"; sa = " + sa + "; sf = " + sf + "; sd = " + sd );

}

}

Obiektów klasy String nie można modyfikować. Na przykład, nie można do pustego napisu wstawić jakiegoś tekstu:

String s = new String ( ); // pusty napis

s = "tekst"; // nowy obiekt !

s = "nowy" + s; // jeszcze jeden obiekt !

Do tworzenia napisów o zmiennej zawartości (buforów tekstowych) służy klasa StringBuffer. Ma ona trzy konstruktory:

StringBuffer ( )

tworzy pusty napis,

StringBuffer ( int max )

tworzy pusty napis z rezerwacją miejsca na max znaków, a

StringBuffer ( String str )

zamienia zwykły napis na bufor tekstowy. Konwersji odwrotnej dokonujemy za pomocą metody toString ( ).

Klasa StringBuffor posiada wszystkie metody klasy String oraz dodatkowo metody modyfikujące napis:

setLength ( int length )	ustala długość napisu
append ( char ch )	dodaje znak na końcu
insert ( int pos, char ch )	wstawia znak na pozycji pos
reverse ( )	odwraca kolejność znaków

Argumentami metod append i insert mogą być również napisy i liczby.

APLIKACJA BUFOR

class Bufor {

… // metoda nagłówek

static String usuń ( String str, int ile ) {

StringBuffer buf = new StringBuffer ( );

buf.append ( str );

buf.reverse ( );

buf.setLength ( buf.length ( ) - ile );

buf.reverse ( );

return buf.toString ( );

}

public static void main ( String [ ] args )

{

String str = "abcde";

String liczby = "0123456789";

String tekst = "akron";

StringBuffer buf = new StringBuffer ( );

nagłówek ( );

// metody klasy StringBuffer

buf.append ( liczby );

buf.setLength ( 5 );

System.out.println("buf = " + buf );

buf.setLength ( 10 );

System.out.println("buf = " + buf );

buf.insert ( 5, tekst );

System.out.println("buf = " + buf );

System.out.println("len = " + buf.length ( ) );

buf.reverse ( );

System.out.println("buf = " + buf );

System.out.println("---------------");

// usunięcie początkowych elementów

System.out.println("str = " + str );

str = usuń ( str, 2 );

System.out.println("str = " + str );

}

}

3.3. Tablice

Tablice w Javie są obiektami. Deklaracja zmiennej tablicowej ma postać:

• <typ> [ ] <nazwa>; |<typ> <nazwa> [ ];

Przykład:

String [ ] tab1; // tablica napisów

int [ ] tab2; // tablica liczb całkowitych

int tab3 [ ]; // alternatywny zapis

W momencie tworzenia nowego obiektu musimy podać wymiar tablicy:

tab1 = new String [ 3 ];

Zapis skrócony:

String [ ] tab1 = new String [ 3 ];

Możemy też od razu nadać elementom tablicy wartości początkowe:

String [ ] tab1 = {"Adam", "Zofia", "Marta"};

int [ ] tab2 = { 1, 2, 3 };

Do określenia liczby elementów tablicy służy zmienna length :

int i = tab2.length; // wynik i = 3

Podobnie jak w innych językach, dostęp do elementu tablicy uzyskujemy podając wskaźnik. Przebiega on wartości od 0 do length - 1 . Tak więc wartość początkowe tablicy tab1 moglibyśmy nadać w taki sposób:

tab1[ 0 ] = "Adam"; tab1[ 1 ] = "Zofia"; tab1[ 2 ] = "Marta";

Elementem tablicy może być dowolny obiekt, a zatem również tablica. W ten sposób możemy tworzyć tablice wielowymiarowe. Na przykład, deklaracja

int [ ] [ ] jeden = {

{ 1, 0, 0 },

{ 0, 1, 0 },

{ 0, 0, 1 }

};

tworzy macierz jednostkową drugiego rzędu.

Uwagi:

1. kompilator sprawdza zakres indeksu;

2. przy tworzeniu obiektu wystarczy podać pierwszy wymiar tablicy;

3. wymiary podtablic mogą być dowolne.

Przykład:

float [ ] [ ] tab = new float [ 3 ] [ ];

tab[ 0 ] = new float [ 5 ];

tab[ 1 ] = new float [ 3 ];

tab[ 2 ] = new float [ 2 ];

tab[ 1 ] [ 3 ] = 12.34; // podwójny błąd !

Do tworzenia tablic o zmiennym wymiarze służy klasa Vector:

Vector v = new Vector ( );

APLIKACJA TABLICE

class Tablice {

… // nagłówek

public static void main(String[] args) {

String [ ] tab1 = new String [ 3 ]; // tablica napisów

int [ ] tab2; // tablica liczb całkowitych

int tab3 [ ]; // alternatywny zapis

// nadawanie wartości początkowych

String [ ] tab4 = {"Adam", "Zofia", "Marta"};

int [ ] tab5 = { 1, 2, 3 };

// tablica dwuwymiarowa

float [ ] [ ] tab6 = new float [ 3 ] [ ];

tab6 [ 0 ] = new float [ 5 ];

tab6 [ 1 ] = new float [ 3 ]; // dowolna długość

tab6 [ 2 ] = new float [ 2 ];

nagłówek ( );

// zmienna length

System.out.println("tab6 [ 1 ].length = " + tab6 [ 1 ].length );

// tab6[ 1 ] [ 3 ] = 12.34; // podwójny błąd !

}

}

Adam Borkowski Język programowania „Java” 3-15

---