Példa buborékrendezésre
int[] n = new int[]{-32,43,53,54,32,0,65,63,98,43,23};
boolean rendezett = false;
while (!rendezett){
rendezett = true;
for (int j=1; j<n.length; j++){
if (n[j-1]>n[j]){
int v = n[j-1];
n[j-1] = n[j];
n[j] = v;
rendezett = false;
}
}
}
System.out.println(Arrays.toString(n));
Tételek
Összegzés
Program.java
class Program
{
public static void main(String[] args)
{
int[] tomb = {3, 8, 2, 4, 5, 1, 6};
int osszeg = 0;
for(int i=0; i<7; i++)
osszeg = osszeg + tomb[i];
System.out.println(osszeg);
}
}
Megszámolás
Program.java
class Program
{
public static void main(String[] args)
{
int[] tomb = {3, 8, 2, 4, 5, 1, 6};
int n = 7;
int szamlalo = 0;
for(int i=0; i<n; i++)
if(tomb[i] > 5)
szamlalo++;
System.out.println(szamlalo);
}
}
Eldöntés tétel
Program.java
class Program
{
public static void main(String[] args)
{
int[] tomb = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // A tömb elemeinek száma
int ker = 2; //Amiről el szeretnénk dönteni, hogy van-e ilyen
int i = 0;
while(i<n && tomb[i] != ker)
i++;
if(i<n)
System.out.println("Van ilyen szám.");
else
System.out.println("Nincs ilyen szám.");
}
}
Kiválasztás tétel
Program.java
class Program
{
public static void main(String[] args)
{
int[] tomb = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // A tömb elemeinek száma
int ker = 2; //Amiről szeretnénk tudni, hogy hányadik helyen van
int i = 0;
while(tomb[i] != ker)
i++;
System.out.printf("%d\n", i + 1);
}
}
Keresés tétel
Program.java
class Program
{
public static void main(String[] args)
{
int[] tomb = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // A tömb elemeinek száma
int ker = 2; //Amit keresünk
int i = 0;
while(i<n && tomb[i] != ker)
i++;
if(i<n) {
//Ha a kérdés az, hogy hányadik akkor i + 1 a vége
//ha a kérdés az, hogy mi az indexe, akkor csak i
System.out.printf("Van ilyen a következő helyen: %d\n", i + 1);
}else {
System.out.println("Nincs ilyen elem");
}
}
}
Kiválogatás tétel
Program.java
class Program
{
public static void main(String[] args)
{
int[] a = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // A tömb elemeinek száma
int[] b = new int[n];
int j=0;
for(int i=0; i<n;i++)
if(a[i] > 5)
b[j++] = a[i];
int m = j; //A "b" tömb elemeinek száma
//Első tömb kiíratva:
for(int i=0; i<n;i++)
System.out.print(a[i] + " ");
System.out.println();
//Második tömb kiíratva:
for(int i=0; i<m;i++)
System.out.print(b[i] + " ");
System.out.println();
}
}
Szétválogatás tétel
Program.java
class Program
{
public static void main(String[] args)
{
int[] a = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // A tömb elemeinek száma
int[] b = new int[n];
int[] c = new int[n];
int j=0;
int k=0;
for(int i=0; i<n;i++)
if(a[i] > 5)
b[j++] = a[i];
else
c[k++] = a[i];
int m = j; //A "b" tömb elemeinek száma
int l = k; //A "c" tömb elemeinek száma
//Első tömb kiíratva:
for(int i=0; i<n;i++)
System.out.print(a[i] + " ");
System.out.println();
//Második tömb kiíratva:
for(int i=0; i<m;i++)
System.out.print(b[i] + " ");
System.out.println();
//Harmadik tömb kiíratva:
for(int i=0; i<l;i++)
System.out.print(c[i] + " ");
System.out.println();
}
}
Metszet tétel
Program.java
class Program
{
public static void main(String[] args)
{
int[] a = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // Az első tömb elemeinek száma
int[] b = {4, 7, 9, 8, 2};
int m = 5; //A második tömb elemeinek száma
int[] c = new int[n+m]; //A harmadik tömb
int j;
int k = 0;
for(int i=0; i<n;i++)
{
j = 0;
while(j<m && b[j] != a[i])
j++;
if(j<m)
{
c[k] = a[i];
k++;
}
}
int l = k; //A "c" tömb elemeinek száma
//Első tömb kiíratva:
for(int i=0; i<n;i++)
System.out.print(a[i] + " ");
System.out.println();
//Második tömb kiíratva:
for(int i=0; i<m;i++)
System.out.print(b[i] + " ");
System.out.println();
//Harmadik tömb kiíratva:
for(int i=0; i<l;i++)
System.out.print(c[i] + " ");
System.out.println();
}
}
Unió tétel
Program.java
/* Unió tétel */
class Program7
{
public static void main(String[] args)
{
int[] a = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // Az első tömb elemeinek száma
int[] b = {4, 7, 9, 8, 2};
int m = 5; //A második tömb elemeinek száma
int[] c = new int[n+m]; //A harmadik tömb
for(int i=0; i<n; i++)
c[i] = a[i];
int k = n-1;
for(int j=0; j<m;j++)
{
int i = 0;
while(i<n && a[i] != b[j])
i++;
if(i>=n)
{
k++;
c[k] = b[j];
}
}
int l = k + 1; //A "c" tömb elemeinek száma
//Első tömb kiíratva:
for(int i=0; i<n;i++)
System.out.print(a[i] + " ");
System.out.println();
//Második tömb kiíratva:
for(int i=0; i<m;i++)
System.out.print(b[i] + " ");
System.out.println();
//Harmadik tömb kiíratva:
for(int i=0; i<l;i++)
System.out.print(c[i] + " ");
System.out.println();
}
}
Maximum kiválasztás tétele
Program.java
class Program
{
public static void main(String[] args)
{
int[] tomb = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // A tömb elemeinek száma
int max = 0;
for(int i=0; i<n;i++)
if(tomb[i] > max)
max = tomb[i];
System.out.println("Legnagyobb: " + max);
}
}
Minimumkiválasztás tétele
Program.java
class Program
{
public static void main(String[] args)
{
int[] tomb = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // A tömb elemeinek száma
int min = tomb[0];
for(int i=0; i<n;i++)
if(tomb[i] < min)
min = tomb[i];
System.out.println("Legkisebb: " + min);
}
}
Rendezések
Buborék rendezés
Program.java
/* Buborék rendezés */
class Program
{
public static void main(String args[])
{
int[] tomb = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // A tömb elemeinek száma
for(int i= n-1; i>0; i--)
for(int j=0; j<i; j++)
if(tomb[j] > tomb[j+1])
{
int tmp = tomb[j];
tomb[j] = tomb[j+1];
tomb[j+1] = tmp;
}
for(int i=0; i<n; i++)
System.out.print(tomb[i] + " ");
System.out.println();
}
}
Vagy:
Program.java
/* Buborék rendezés */
class Program
{
public static void main(String args[])
{
int[] tomb = {3, 8, 2, 4, 5, 1, 6};
int n = 7; // A tömb elemeinek száma
for(int i= n-2; i>0; i--)
for(int j=0; j<=i; j++)
if(tomb[j] > tomb[j+1])
{
int tmp = tomb[j];
tomb[j] = tomb[j+1];
tomb[j+1] = tmp;
}
for(int i=0; i<n; i++)
System.out.print(tomb[i] + " ");
System.out.println();
}
}
Utóbbi különbsége: mettől-meddig megyünk a ciklusban.
Beszúrásos rendezés
Rekurzív megvalósítás:
Program01.java
package rendezesbeszurassal;
public class RendezesBeszurassal {
static void rendezesBeszurassalR(int[] t, int n) {
if(n>0) { // eredeti: n>1
rendezesBeszurassal(t, n-1);
int x = t[n-1]; // eredeti: t[n]
int j = n-2; // eredeti: n-1
while(j>= 0 && t[j]>x) {
t[j+1] = t[j];
j = j-1;
}
t[j+1] = x;
}
}
static void kiir(int[] t) {
for (int i = 0; i < t.length; i++) {
System.out.print(t[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
int[] t = {35, 24, 83, 12, 7, 23};
rendezesBeszurassalR(t, t.length);
kiir(t);
}
}
Normál megvalósítás:
static void rendezesBeszurassal(int[] t) {
for (int i = 0; i < t.length; i++) { //eredeti: i=1
int x = t[i];
int j = i - 1;
while(j>=0 && t[j]>x) {
t[j+1] = t[j];
j = j - 1;
}
t[j+1] = x;
}
}
A megjegyzések azokra a tömbökre utalnak, ahol a kezdőérték 1.
Gyorsrendezés
Program.java
class Program
{
static void gyors(int[] tomb, int bal, int jobb)
{
if(bal < jobb)
{
int also = bal, felso = jobb + 1, kulcs = tomb[bal];
for( ; ; )
{
while(++also < felso && tomb[also] < kulcs)
;
while(tomb[--felso] > kulcs)
;
if(also >= felso)
break;
csere(tomb, also, felso);
}
csere(tomb, felso, bal);
gyors(tomb, bal, felso -1);
gyors(tomb, felso+1, jobb);
}
}
static void csere(int[] tomb, int i, int j)
{
int seged = tomb[i];
tomb[i] = tomb[j];
tomb[j] = seged;
}
public static void main(String args[])
{
int[] tomb = {8, 5, 2, 9, 4, 3, 1, 6};
int meret = 8;
gyors(tomb, 0, 7);
for(int i=0; i<meret; i++)
System.out.print(tomb[i] + " ");
System.out.println();
}
}
Program01.java
import java.util.ArrayList;
import java.util.Arrays;
public class Program01 {
static ArrayList<Integer> quicksort(ArrayList<Integer> list) {
if (list.size() <= 1) {
return list;
}
ArrayList<Integer> less = new ArrayList<>();
ArrayList<Integer> equal = new ArrayList<>();
ArrayList<Integer> greater = new ArrayList<>();
int pivot = list.get(list.size()-1);
for (Integer x : list) {
if (x < pivot) less.add(x);
if (x == pivot) equal.add(x);
if (x > pivot) greater.add(x);
}
ArrayList<Integer> sumList = new ArrayList<Integer>();
sumList.addAll(quicksort(less));
sumList.addAll(equal);
sumList.addAll(quicksort(greater));
return sumList;
}
static void kiirLista(ArrayList<Integer> list) {
for(Integer x : list) {
System.out.print(x + " ");
}
System.out.println();
}
public static void main(String[] args) {
Integer[] t = {8, 2, 7, 9, 5, 4, 3};
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(t));
list = quicksort(list);
kiirLista(list);
}
}
Program01.java
import java.util.ArrayList;
import java.util.Arrays;
public class Program01 {
static void quicksort(ArrayList<Integer> list, int lo, int hi) {
if(lo < hi) {
int p = partition(list, lo, hi);
quicksort(list, lo, p-1);
quicksort(list, p+1, hi);
}
}
static int partition(ArrayList<Integer> list, int lo, int hi) {
int pivot = list.get(hi);
int i = lo -1;
for (int j = lo; j < hi; j++) {
if(list.get(j)<= pivot) {
i++;
swap(list, i, j);
}
}
swap(list, i+1, hi);
return i + 1;
}
static void swap(ArrayList<Integer> list, int i, int j) {
int tmp = list.get(i);
list.set(i, list.get(j));
list.set(j, tmp);
}
static void kiir(ArrayList<Integer> list) {
for(Integer x : list) {
System.out.print(x + " ");
}
System.out.println();
}
public static void main(String[] args) {
Integer[] t = {8, 2, 7, 3, 4, 9};
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(t));
quicksort(list, 0, list.size()-1);
kiir(list);
}
}
Shell rendezés
Program.java
class Program
{
public static void main(String args[])
{
int[] tomb = {8, 5, 2, 9, 4, 3, 1, 6};
int[] leptomb = {5, 3, 1};
int meret = 8;
for(int k = 0; k< 3; k++)
{
int lepeskoz = leptomb[k];
for(int j = lepeskoz; j < meret; j++)
{
int i = j - lepeskoz;
int kulcs = tomb[j];
while(i>=0 && tomb[i] > kulcs)
{
tomb[i + lepeskoz] = tomb[i];
i = i - lepeskoz;
}
tomb[i + lepeskoz] = kulcs;
}
}
for(int i=0; i<meret; i++)
System.out.print(tomb[i] + " ");
System.out.println();
}
}
Összefuttatás
Összefuttatás, összefésülés
Program01.java
class Program01{
public static void main(String[] args) {
int[] a = { 1, 3, 5, 7, 9};
int[] b = {2, 4, 6, 8 };
int[] c = new int[a.length+b.length];
int n = a.length;
int m = b.length;
int i = 0;
int j = 0;
int k = -1;
while(i<n && j<m) {
k++;
if(a[i]<b[j]) {
c[k] = a[i];
i++;
}else if(a[i] == b[j]) {
c[k] = a[i];
i++;
j++;
}else if(a[i] > b[j]) {
c[k] = b[j];
j++;
}
}
while(i<n) {
k++;
c[k] = a[i];
i++;
}
while(j<m) {
k++;
c[k] = b[j];
j++;
}
kiir(c, k);
}
public static void kiir(int[] tomb, int meret) {
for (int i = 0; i < meret + 1; i++) {
System.out.println(tomb[i]);
}
}
Keresés rendezett tömbben
Logaritmikus keresés
Program01.java
public class Program01 {
public static void main(String[] args) {
int[] t={3, 4, 6, 8, 18, 50, 52, 61, 68, 70};
int n = t.length;
int e = 0;
int u = n-1;
int k;
int ker = 52;
do {
k = (e+u) / 2;
if(ker<t[k]) u = k-1;
if(ker>t[k]) e = k+1;
}while(e<=u && t[k]!=ker);
boolean van = e<=u;
int index = 0;
if(van) {
index = k;
}
System.out.printf("%s %d\n", van, index);
}
}
Rendezések
helyfoglalási igény
lépésszám
egyszerű cserés rendezés
minimumkiválasztásos rendezés
buborékos rendezés
javított buborékos rendezés
gyors rendezés
Másik példa
BuborékosRendezés
A program buborékos rendezés alkalmazásával rendezze a tömbelemeket!
Az alapelv: szomszédos elemeket hasonlítsunk össze, és ha nem megfelelő a sorrendjük, akkor cseréljük fel őket. Egy ciklus alatt a legnagyobb elem biztosan a helyére (a tömb végére) kerül, és ezen kívül a tömbelemek a helyük felé mozognak (a kisebbek balra, a nagyobbak jobbra).
Forráskód
public class BuborékosRendezés {
final static int N=20;
static int[] tömb = new int[N+1];
static void tömbFeltölt() {
for(int i=1; i<=N; i++)
tömb[i]=(int)(Math.random()*90+10);
}
static void tömbLista(String üzenet) {
System.out.println(üzenet);
for(int i=1; i<N; i++)
System.out.print(tömb[i]+", ");
System.out.println(tömb[N]);
}
static void tömbRendez() { // buborékos rendezés
int csere;
for(int i=N; i>=2; i--) { //1
for(int j=1; j<=i-1; j++) //2
if(tömb[j]>tömb[j+1]) { //3
csere=tömb[j]; //4
tömb[j]=tömb[j+1];
tömb[j+1]=csere;
}
}
}
public static void main(String[] args) {
tömbFeltölt();
tömbLista("A tömb elemei a rendezés előtt:");
tömbRendez();
tömbLista("A tömb elemei a rendezés után:");
}
}
A program lehetséges futása
A tömb elemei a rendezés előtt:
84, 87, 71, 47, 89, 96, 27, 60, 98, 65, 74, 59, 67, 64, 12, 35, 58, 90, 51, 35
A tömb elemei a rendezés után:
12, 27, 35, 35, 47, 51, 58, 59, 60, 64, 65, 67, 71, 74, 84, 87, 89, 90, 96, 98
Elemzés
A külső ciklus (//1) a tömb utolsó elemétől egyesével visszafelé halad a 2. elemig. A belső ciklus (//2) a külső ciklus aktuális i-edik elemétől balra lévő i-1 db elemen dolgozik. Ha két szomszédos tömbelem (j-edik és j+1-edik) sorrendje nem megfelelő (//3), akkor fel kell azokat cserélni (//4).
Az algoritmus nem veszi észre (mert nem figyeli, hogy volt-e csere a belső ciklusban), ha időközben befejeződik a rendezés. Ha volt csere, akkor csak a csere helyétől balra lévő elemekkel kellene foglalkozni, de az algoritmus erre sem figyel. Futtassa a BuborékosRendezésDemo programot, hogy lépésenként kiírva tudja követni, hogyan működik az algoritmus.
összetett programozási tételek
metszet
egyesítés (unió)
összefuttatás
Keresések
lineáris keresés
logaritmikus keresés
MásodikLegnagyobbTömbelem
A program egy véletlenszerű értékekkel feltöltött és csökkenő sorrendbe rendezett tömböt feldolgozva írja ki a tömb második legnagyobb elemét (ha van) a konzolra!
Java osztályok használata
rt.jar
10.1. Csomagolóosztályok
java.lang.Character
java.lang.Boolean
java.lang.Byte
java.lang.Short
java.lang.Integer
java.lang.Long
java.lang.Float
java.lang.Double
10.2. A String és StringBuffer osztályok
java.lang.String
java.lang.StringBuffer
unikód karakterek sorozata
indexelhető
null referencia
10.2.2. Feladat - Köszön2
A program addig kérje be a felhasználó vezeték- és keresztnevét, amíg meg nem adja, majd köszönjön!
Forráskód
public class Köszön2 {
public static void main(String[] args) {
String vezetékNév=null, keresztNév=null; //1
while((vezetékNév=extra.Console.
readLine("Vezetékneve: ")).equals("")) //2
System.out.println("Hiányzó vezetéknév. Újra!"); //3
while((keresztNév=extra.Console.
readLine("Keresztneve: ")).equals("")) //3
System.out.println("Hiányzó keresztnév. Újra!");
System.out.println("Üdvözlöm "+vezetékNév+" "+
keresztNév+"!"); //4
}
}
A program lehetséges futása
Vezetékneve:
Hiányzó vezetéknév. Újra!
Vezetékneve: Domján
Keresztneve: Erika
Üdvözlöm Domján Erika!
Elemzés
A program mindkét változót null kezdőértékkel hozza létre (//1). Az objektumok összehasonlítására, egyezőségük vizsgálatára nem alkalmasak a primitív adattípusoknál használható relációs jelek. Az objektumok egyenlőségét az equals() metódussal lehet eldönteni. A ciklusban történő beolvasás addig fut, amíg egy üres String-től különböző szöveget meg nem ad a felhasználó (//2 és //3). A kiíró utasítás állítja elő a nevet (//4), azt külön változó nem tárolja.
10.3. A java.util.Random osztály
véletlen egész szám, valós szám, logikai érték
10.4. A java.util.Date és java.text.DateFormat osztályok
UTC
Tömbök
tömbelem
tömbindex
elemszám
dimenzió
egydimenziós
többdimenziós
8.1. Egydimenziós tömbök
műveletek
létrehozás
feltöltés
inicializáló blokk
egyesével forráskódból
egyesével konzolról bekérve
véletlenszerűen
listázás
8.1.6. Feladat - Ötöslottó1
A program írjon ki a konzolra egy ötöslottón megjátszható számkombinációt! Az öt véletlenszám egymástól különbözik, és mindegyik 1 és 90 közé esik. A megoldáshoz a program logikai tömböt használjon!
Forráskód
public class ÖtösLottó1 {
public static void main(String[] args) {
boolean[] logikaiTömb=new boolean[91]; //1
for(int i=1; i<=90; i++) //2
logikaiTömb[i]=false; //3
int jóSzámDb=0, tipp; //4
while(jóSzámDb<=5) { //5
tipp=(int)(Math.random()*90+1); //6
if(!logikaiTömb[tipp]) { //7
logikaiTömb[tipp]=true; //8
jóSzámDb++; //9
}
}
System.out.print("Ötöslottón megjátszható számok: ");
for(int i=1; i<=90; i++) //10
if(logikaiTömb[i]) //11
System.out.print(i+" "); //12
}
}
A program lehetséges futása
Ötöslottón megjátszható számok: 18 28 44 75 77
Elemzés
A program 91 elemű logikai tömböt hoz létre (//1), nem használja annak nulladik elemét, így 1-től 90-ig indexelhető. Ha valamelyik eleme (i) igaz, akkor ez jelentse azt, hogy azt az elemét (i-ediket) meg kell játszani. Kezdetben a logikaiTömb minden eleme hamis (//2 és //3).
Két segédváltozóra is szükség van (//4). A jóSzámDb jelöli az egymástól különböző lottószámokat. Kezdetben 0, pedig az első véletlenszerűen előállított tipp biztosan jó lesz (nem fordulhat elő, hogy egy korábban előállított számmal megegyezik), de a későbbi összehasonlítások (pl.: az 1. szám megegyezik-e a 3.-kal?). Az elöltesztelős ciklus (//5) feltétele is beszédes (jóSzámDb<=5). A ciklusmag először előállít egy lottószámot (//6). Ezután, ha ilyen még nem volt (//7), akkor meg kell jegyezni (//8) és növelni kell a jóSzámDb változó értékét (//9). Ha olyan a tipp, ami már volt, akkor nincs teendő, tehát nem nő a jóSzámDb változó értéke, így a ciklus belépési feltétele (jóSzámDb<=5) továbbra is teljesül.
A logikaiTömb végül biztosan tartalmaz 5 db true értéket. Ezek indexét kell kiírni (//10, //11, //12), hogy megkapjuk az ötöslottó szelvényen megjátszható véletlenszámokat. Számlálós ciklust nem lehet használni az öt egymástól különböző lottószám előállítására, mert akár többször is előfordulhat, hogy egy tipp megegyezik egy korábban előállított véletlen lottószámmal. Ez a módszer memóriahasználat szempontjából pazarló. 5 egymástól különböző véletlenszám előállításához 90+1 elemű tömböt használ. A módszer "mellékhatása", hogy a lottószámok - mivel a tömböt (//10) a kisebb indexektől a nagyobb indexek felé haladva írja ki - rendezett sorozatot alkotnak.
8.2. Programozási tételek, 2. rész
elemi programozási tételek
sorozatszámítás
eldöntés
kiválasztás
(lineáris) keresés
megszámlálás
maximumkiválasztás
összetett programozási tételek
másolás
kiválogatás
szétválogatás
Metódusok írása
metódus
eljárás
függvény
készítésének okai
7.1. Metódusok paraméterei és visszatérési értékük
metódushívás
paraméter
formális
aktuális
paraméterátadás
érték szerinti
metódusok sorrendje
rekurzív függvény
7.1.3. Feladat - Időtartam1
A program másodpercben megadott időtartamot fejezzen ki óra:perc:másodperc formában! Ellenőrizni nem kell! A megvalósítást egy külön eljárás végezze!
Forráskód
public class Időtartam1 {
static void időtartam(int mp) { //nincs ellenőrzés
int másodperc=mp; //1
int óra=másodperc/3600;
másodperc%=3600; //2
int perc=másodperc/60;
másodperc%=60;
System.out.println(mp+" másodperc = "+ //3
óra+":"+perc+":"+másodperc);
}
public static void main(String[] args) {
System.out.println("Időtartam: "+
"másodperc -> óra:perc:másodperc");
időtartam(11502); //4
}
}
A program futása
Időtartam: másodperc -> óra:perc:másodperc
11502 másodperc = 3:11:42
Elemzés
Az időtartam() eljárás a 11502 aktuális paramétert kapja (//4), amely az mp formális paraméterbe kerül. A számoláshoz szükséges néhány lokális változó (másodperc, óra, perc), amelyek az eljárás blokkjában jönnek létre és csak addig élnek (láthatóak, foglalnak memóriaterületet), amíg az eljárás fut. Az eredmény kiírásakor (//3) szükség van az eredeti mp értékre - és azt a számolás során az eljárás módosítja (például //2) -, így első teendő az mp értékének mentése a másodperc változóba (//1). A számolás menete egyértelmű. Ellenőrzés nincs, feltételezzük, hogy az időtartam() eljárás paramétere mindig pozitív.
Iterációk
ciklus
ciklusváltozó
ciklusmag
egymásba ágyazott ciklusok
feltétel
de Morgan-azonosságok
6.1. Számláló ciklus
Mikor használjuk?
inicializálás
belépési feltétel
ciklusmag
léptetés
6.2. Elöltesztelő ciklus
Mikor használjuk?
belépési feltétel
ciklusmag
6.3. Hátultesztelő ciklus
Mikor használjuk?
ciklusmag
bennmaradási feltétel
6.4. Programozási tételek, 1. rész
elemi programozási tételek
sorozatszámítás
eldöntés
kiválasztás
(lineáris) keresés
megszámlálás
maximumkiválasztás
6.4.6. Feladat - NéhánySzámÖsszege1
A program adjon össze néhány számot! Előre nem tudjuk, hogy a felhasználó hány számot szeretne összeadni! A (sorozatos) bevitel végét jelölje a 0 (nulla) végjel!
Forráskód
public class NéhánySzámÖsszege1 {
public static void main(String[] args) {
System.out.println("Beolvasott néhány szám összege "+
"(végjel: 0)");
final int VÉGJEL=0; //1
int db=0, összeg=0, szám; //2
while((szám=extra.
Console.readInt((db+1)+". szám: "))!=VÉGJEL) { //3
összeg+=szám;
db++;
}
System.out.println("A megadott "+db+
" szám összege "+összeg+".");
}
}
A program lehetséges futása (1)
Beolvasott néhány szám összege (végjel: 0)
1. szám: 12
2. szám: 75
3. szám: -8
4. szám: 5
5. szám: 0
A megadott 4 szám összege 84.
A program lehetséges futása (2)
Beolvasott néhány szám összege (végjel: 0)
1. szám: 0
A megadott 0 szám összege 0.
Elemzés
A VÉGJEL konstans (//1). A feladatot csak feltételes ciklussal lehet megoldani. A beolvasott szám feldolgozásakor növeljük vele az - előzőleg nullázott (//2) - összeg nevű gyűjtőt. A db változó nem szükséges csupán a sorszámozott bekérést (//3) biztosítja, ahogyan az (1) lehetséges futásnál látható. A végjelet nem szabad feldolgozni. A programnak akkor is jól kell működnie, ha a felhasználó egyetlen számot sem akar összegezni: (2) lehetséges futás.
Szelekciók
5.1. Egyágú szelekció
5.2. Többágú szelekció
feltételes kiértékelés
szelekciók egymásba ágyazása
5.2.1. Feladat - Pozitív2
A program egy bekért egész szám előjelétől függően írja ki, hogy a szám pozitív vagy sem!
Forráskód
public class Pozitív2 {
public static void main(String[] args) {
System.out.println("Pozitív-e a megadott szám?");
int szám = extra.Console.readInt("Szám: ");
if(szám>0)
System.out.println("A szám pozitív.");
else //1
System.out.println("A szám nem pozitív.");
}
}
A program lehetséges futása
Pozitív-e a megadott szám?
Szám: -95
A szám nem pozitív.
Elemzés
A programot futtatva bármilyen számot is ad meg a felhasználó, mindenképpen tenni kell valamit. Mindig a megfelelő szöveget kell kiírni a konzolra.
Az if feltételes utasítás a beolvasást követi. Ekkor már tudunk dönteni arról, hogy pozitív-e a megadott szám. A logikai feltételt (szám>0) zárójelbe kell írni. Az utasítás végén nincs pontosvessző! A feltétel teljesülésekor most egyetlen végrehajtandó utasítás (//1) van.
Az else kulcsszó valósítja meg a Java nyelvben a feltételes utasítás hamis ágát. Az else kulcsszó után írt utasítás (vagy blokk) (//2) akkor hajtódik végre, ha a feltétel nem teljesül, azaz hamis.
A feltételes utasítás igaz és hamis ága közül pontosan az egyik hajtódhat végre!
Kifejezések, értékadás
4.1. Kifejezések alkotóelemei
- operandus
- operátor
- egyenrangú multiplikatív
- additív
- implicit típuskonverzió
4.1.2. Feladat - HőmérsékletFC
A program legyen képes Fahrenheit fokban megadott hőmérsékletet
átváltani Celsius fokra! Tárolja a beolvasott hőmérsékletet egy valós
típusú
f nevű változó! Ekkor az átváltás képlete:
(f-32)*5/9.
Forráskód
public class HőmérsékletFC {
public static void main(String[] args) {
System.out.println("Fahrenheit -> Celsius");
double f=extra.Console.readDouble("Fahrenheit fok: ");
double c=(f-32)*5/9; //1
System.out.println("Celsius fok: "+c);
}
}
A program lehetséges futása
Fahrenheit -> Celsius
Fahrenheit fok: 99.8
Celsius fok: 37.666666666666664
Elemzés
A program a valós
c változó kiszámításakor (
//1) először a zárójelben lévő kifejezést számítja ki, majd balról jobbra halad tovább:
c=(f-32), c=(f-32)*5, végül
c=(f-32)*5/9. A futás eredményénél érzékelhető (a törtrész "végén" lévő
4) a
double adattípus pontossága.
4.2. Operátorok
- operátor
- explicit típuskényszerítés
- asszociativitás
- értékadási kompatibilitás
4.3. Léptető operátorok
4.4. A Math osztály fontosabb metódusai
- túlterhelt metódusok
- szignatúra
4.5. Véletlenszámok előállítása
Math.random()- [A; B] zárt intervallumból generálunk egy egész véletlenszámot
Alapfogalmak
3.1. Első Java programunk
osztály
blokk
main metódus
konzol
forráskód formázása
3.2. A Java programok alkotóelemei
unikód karakter
fehér szóköz
megjegyzés
azonosító
kulcsszó
literál
szeparátor
operátor
3.3. Változó, adattípus
változó
adattípus
primitív numerikus adattípusok
karakter típus
logikai típus
Grafikus felhasználói felület felépítése
GUI elemei
látható komponensek
nem látható elemek
AWT
java.awt csomag
Swing
javax.swing csomag
16.1. Áttekintés
AWT és Swing osztályhierarchia
16.2. Nem látható elemek
java.awt.Point
java.awt.Dimension
java.awt.Rectangle
java.awt.Toolkit
16.3. Első lépések a GUI felé
java.swing.JFrame
java.awt.Font
javax.swing.JLabel
javax.swing.JButton
javax.swing.JPanel
javax.swing.SwingConstants
16.4. Elrendezésmenedzserek
java.awt.FlowLayout
java.awt.GridLayout
java.awt.BorderLayout
javax.swing.BoxLayout
javax.swing.OverlayLayout
Swing-komponensek
MVC-modell
háromrétegű architektúra: modell, view, controller
18.1. Címke - JLabel
18.2. Nyomógomb - JButton
18.3. Jelölőnégyzet - JCheckBox
18.4. Rádiógomb - JRadioButton
18.4.1. Feladat - Rádiógomb1
A program kínálja fel egy számla kiegyenlítéskor megadható fizetési módokat: készpénz, átutalás, csekk! Alapértelmezett a készpénzes fizetési mód! A felhasználó által kiválasztott fizetési mód egy címkében jelenjen meg! A megvalósításhoz rádiógombokat használjon!
Forráskód
import java.awt.*;
import java.awt.event.*;
import javax.swing.ButtonGroup;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
public class Rádiógomb1 extends JFrame
implements ActionListener {
private JLabel lbFizetésiMód=new JLabel();
private JRadioButton rbKészpénz=
new JRadioButton("készpénz", true); //1
private JRadioButton rbÁtutalás=
new JRadioButton("átutalás"); //2
private JRadioButton rbCsekk=new JRadioButton("csekk");
private ButtonGroup bg=new ButtonGroup(); //3
public Rádiógomb1() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setTitle("Fizetési mód");
setSize(250, 120);
setLocationRelativeTo(this);
setLayout(new FlowLayout()); //4
JPanel pn1=new JPanel(new GridLayout(2, 1)); //5
pn1.add(new JLabel("Fizetési mód: ")); //6
pn1.add(lbFizetésiMód); //7
add(pn1);
JPanel pn2=new JPanel(new GridLayout(3, 1)); //8
pn2.add(rbKészpénz); bg.add(rbKészpénz); //9
pn2.add(rbÁtutalás); bg.add(rbÁtutalás);
pn2.add(rbCsekk); bg.add(rbCsekk);
add(pn2);
rbKészpénz.addActionListener(this); //10
rbÁtutalás.addActionListener(this);
rbCsekk.addActionListener(this);
rbKészpénz.doClick(); //11
setVisible(true);
}
public void actionPerformed(ActionEvent e) {
String fizetésiMód=
((JRadioButton)e.getSource()).getText(); //12
lbFizetésiMód.setText(fizetésiMód); //13
}
public static void main(String[] args) {
new Rádiógomb1();
}
}
Fájlkezelés
bejegyzés
fájltartalom feldolgozása
folyam
közvetlen elérés
java.io csomag
19.1. A File osztály
java.io.File
bejegyzés
állomány
mappa
fizikai név
logikai név
19.2. Szűrés, kiválasztás
java.io.FilenameFilter
javax.swing.JFileChooser
19.3. Műveletek bejegyzésekkel
19.4. Szövegfájlok
java.io.FileReader
java.io.FileWriter
19.4.1. Feladat - SzövegFájl1
A program az üres szöveget végjelnek tekintve olvasson be a konzolról szövegeket és mentse a files/szöveg.txt szövegfájlba!
Forráskód
import java.io.File;
import java.io.FileWriter; //1
import java.io.IOException;
public class SzövegFájl1 {
public static void main(String[] args) {
File szövegFájl=new File("./files/szöveg.txt");
try {
FileWriter fw=new FileWriter(szövegFájl); //2
int sorDb=0;
String sor;
while(!(sor=extra.Console.readLine(
++sorDb+". sor: ")).equals("")) //3
fw.write(sor+"\r\n"); //4
fw.close(); //5
}
catch(IOException e) {
System.out.println("I/O hiba: "+e.getMessage());
}
}
}
A program lehetséges futása
1. sor: alma
2. sor: barack
3. sor: dinnye
4. sor:
Elemzés
A program importálja a fájlba író karakterfolyamot megvalósító FileWriter osztályt (//1). Az fw objektum kiviteli karakterfolyamként jön létre (//2), amely az esetleg már létező fájlt felülírja. A kétparaméteres konstruktorát használva (FileWriter(szövegFájl, true)) használható lenne már létező állomány bővítésére is. A ciklus üres String végjelig (Enter-ig) olvassa a sor-t a konzolról (//3) és írja a folyamba (//4). A sor végét meg kell adni: "\r\n". Végül bezáródik a folyam (//5).
19.5. Folyamok
folyam
bemeneti folyamok
java.io.ByteArrayInputStream
java.io.FileInputStream
java.io.DataInputStream
java.io.ObjectInputStream
java.io.Reader
kimeneti folyamok
java.io.ByteArrayOutputStream
java.io.FileOutputStream
java.io.DataOutputStream
java.io.ObjectOutputStream
java.io.Writer
adatfeldolgozási irány
adatmozgatási egység
Serializable interfész
19.6. Beállítófájlok
java.util.Properties
------------------------------
/*
* Készítsünk programot, amely véletlen számokat generál.
*/
package veletlen;
import java.util.Random;
public class Veletlen {
public static void main(String[] args) {
Random rnd = new Random();
System.out.println("Véletlen számok generálása.");
//Egy véletlen szám.
System.out.println("Paraméter nélkül: "+rnd.nextInt());
//0..30 közötti véletlen szám.
System.out.println("0..30 közötti véletlen szám: "+rnd.nextInt(31));
//20..60 közötti véletlen szám.
System.out.println("20..60 közötti véletlen szám:"+
(rnd.nextInt(41)+20));
}
}
-------------
/*
* Kockadobás szimulációja, metódusok és tömbök felhasználásával.
*/
package tombok;
import java.util.Random;
public class Tombok {
/ public static void main(String[] args) {
// Tömb feltöltése
int [] tomb = new int[30];
int [] tombDobas = new int[6];
tombFeltolt(tomb, 1, 6);
// Tömb kiíratása
tombKiir(tomb);
//Kockadobás statisztikája
dobasStat(tomb, tombDobas);
System.out.println("\nDobások statisztikája:");
System.out.println("\n1 - 2 - 3 - 4 - 5 - 6");
tombKiir(tombDobas);
}
//Adott tömböt véletlen értékekkel feltöltő metódus
public static void tombFeltolt(int[] t, int kezd, int veg){
Random rnd = new Random();
for(int i = 0; i < t.length; i++)
t[i] = rnd.nextInt(veg-kezd+1)+kezd;
}
//Adott tömb kiírása a képernyőre.
public static void tombKiir(int[] t){
for(int i = 0; i < t.length; i++){
if((i % 10 == 0) && (i != 0))
System.out.println();
System.out.print(t[i]+", ");
}
}
public static void dobasStat(int [] t, int [] dStat){
//A dStat elemeit nem kell nullázni, mert nullarendű kezdőértéket kapnak.
for(int i = 0; i < t.length; i++){
switch(t[i]){
case 1: {dStat[0]++; break;}
case 2: {dStat[1]++; break;}
case 3: {dStat[2]++; break;}
case 4: {dStat[3]++; break;}
case 5: {dStat[4]++; break;}
case 6: {dStat[5]++; break;}
}
}
}
}
------------------
http://www.szerencsiszakkepzo.sulinet.hu/jegyzet/info/Tetelek_db_szum_atlag.pdf
-----------------
/*
* Töltsünk fel egy tömböt véletlenszerűen, az adott index kétszeres értékével.
*/
package veletlentomb;
import java.util.Arrays;
import java.util.Random;
public class VeletlenTomb {
public static void main(String[] args) {
Random rnd = new Random();
int[] t = new int[30];
System.out.println("Tömb indexeinek kiíratása:");
for(int i = 0; i < t.length; i++)
System.out.printf("%3d,",i);
System.out.println("\n");
Arrays.fill(t, -1);
System.out.println("Inicializálás után a tömb elemeinek kiíratása:");
//foreach ciklussal
for(int e: t)
System.out.printf("%3d,",e);
//a soremelés miatt
System.out.println("\n");
int szamlalo = 30;
int vi = -1; //véletlen index
do{
do{
vi = rnd.nextInt(30);
}while(t[vi] != -1);
t[vi] = 2 *vi;
szamlalo--;
}while(szamlalo > 0);
System.out.println("Tömb elemeinek kiíratása - index kétszerese -");
//foreach ciklussal
for(int e: t){
System.out.printf("%3d,",e);
}
//soremelés miatt
System.out.println("");
}
}
-------------------
/*
* Prímszámok meghatározása.
*/
package primek;
public class Primek {
public static void main(String[] args) {
//2000-től 20001-ig keressük meg a prímszámokat!
int primekszama = 0;
for (int n = 2000; n <= 20001; n++) {
int i = 2;
double sq = Math.sqrt(n);
while ((n%i != 0) && (i <= sq)) {
i++;
}
if (i > sq) {
primekszama++;
if (primekszama % 15 != 0){
System.out.print(n+", ");
}
else {
System.out.println();
System.out.print(n+", ");
}
}
}
System.out.println("");
System.out.println("Primek száma 2000 és 20000 között: "
+primekszama+" darab.");
}
}
----------------
/*
* Stringeket tartalmazó tömb.
* Kérjünk be 5 karakterláncot és listázzuk ki.
*/
package stringtomb;
import java.util.Scanner;
public class StringTomb {
public static void main(String[] args) {
// TODO code application logic here
Scanner be = new Scanner(System.in);
String [] st = new String[5];
// tömb feltöltése
for(int i = 0; i < st.length; i++){
System.out.print((i+1)+". gyümölcs: ");
st[i] = be.nextLine();
}
// szöveg kiírása egymás alá
System.out.println("\nA megadott gyümölcsök listája fordított sorrendben");
for(int i = st.length-1; i >= 0; i--)
System.out.println(st[i]);
}
}
---------------------
/*
* Készíts Java programot. Kérje be egy telek oldalait a felhasználótól
* méterben. Írja ki a telek területét négyszögölben (1 n-öl = 3.6 m2).
* Ha a telek 100 négyszögölnél kisebb, akkor írja ki, hogy túl kicsi!
* Felhasználóbarát program!
*/
package telek;
import java.util.Scanner;
public class Telek {
public static void main(String[] args) {
Scanner be = new Scanner(System.in);
double a, b, nOl, t;
System.out.println("Telek oldalainak megadása:");
System.out.print("a = ");
a = be.nextDouble();
System.out.print("b = ");
b = be.nextDouble();
t = a* b; //négyzetméterben
nOl = t / 3.6; //négyzetölben
System.out.println("Terület négyzetölben: "+nOl);
if(nOl < 100)
System.out.println("Túl kicsi.");
}
}
