- How to Think Like a Computer Scientist with Java – http://www.oopweb.com/Java/Documents/ThinkCSJav/VolumeFrames.html
- Introduction to Programming Using Java – http://www.oopweb.com/Java/Documents/IntroToProgrammingUsingJava/VolumeFrames.html
- Introduction To Programming Using Java -
- http://www.linuxtopia.org/online_books/programming_books/introduction_to_java_programming/index.html
- Java Programming Tutorial: Introduction to Computer Science – http://www.oopweb.com/Java/Documents/JavaNotes/VolumeFrames.html
- Thinking in Java, 3rd Edition – http://www.mindview.net/Books/TIJ/
- Thinking in Enterprise Java – http://www.ibiblio.org/pub/docs/books/eckel/
- Java AWT Reference - http://www.oreilly.com/catalog/javawt/book/index.html
- Enterprise JavaBeans - http://www.computer-books.us/java_1.php
- Essentials of the Java Programming Language – Part 1 – http://www.computer-books.us/java_2.php
- Essentials of the Java Programming Language – Part 2 – http://www.computer-books.us/java_3.php
- Exploring Java – http://www.computer-books.us/java_4.php
- Introduction to Computer Science using Java – http://www.computer-books.us/java_5.php
- Java Language Reference - http://www.computer-books.us/java_8.php
- Java Servlet Programming – http://www.computer-books.us/java_9.php
- Java Web Services Tutorial – http://www.computer-books.us/java_10.php
- Java Look and Feel Design Guidelines, Second Edition – http://java.sun.com/products/jlf/ed2/book/index.html
- The Design Patterns: Java Companion – http://www.patterndepot.com/put/8/JavaPatterns.htm
- 1000 Java Tips e-Book – http://javaa.com
- Apache Jakarta Commons: Reusable Java™ Components – http://www.phptr.com/promotion/1484?redir=1
- Java™ Application Development on Linux® – http://www.phptr.com/promotion/1484?redir=1
- Practical Artificial Intelligence Programming in Java – http://www.markwatson.com/opencontent/javaai_lic.htm
- Sun Java Tutorials -http://java.sun.com/learning/tutorial/index.html
- Introduction to Programming Using Java Version 3.1 – http://math.hws.edu/eck/cs124/javanotes3/
- Introduction to Programming Using Java Version 4.1 – http://math.hws.edu/javanotes/
- Sams Teach Yourself Java 2 in 24 Hours – http://www.samspublishing.com/library/library.asp?b=STY_Java2_24hours
- CORE SERVLETS and JAVASERVER PAGES – http://pdf.coreservlets.com/
- From Java to Sumatra – http://staff.science.uva.nl/~heck/JAVAcourse/s.html
- 20 Different Borland JBuilder books – http://info.borland.com/techpubs/jbuilder/
- Java Precisely 1.05 – http://www.dina.kvl.dk/~sestoft/javaprecisely/javaprecisely-online.pdf
- Processing XML with Java – http://www.cafeconleche.org/books/xmljava/
- Learning to Program Java – http://books.iuniverse.com/viewbooks.asp?isbn=059535422X&page=fm1
- Java & Internet Security - http://books.iuniverse.com/viewbooks.asp?isbn=0595135005&page=fm1
- First Course: Data Structures and Algorithms Using Java – http://books.iuniverse.com/viewbooks.asp?isbn=0595318967&page=fm1
- The Visual Basic Programmer’s Guide to Java – http://books.iuniverse.com/viewbooks.asp?isbn=1583482172&page=fm1
- Bleeding at the Keyboard: A Guide to Modern Programming with Java – http://www.roxie.org/books/bleeding/tableofcontents.html
- Securing Java – http://www.securingjava.com/toc.html
- Java an Object First Approach – http://www.scism.sbu.ac.uk/jfl/jflcontents.html
- Processing XML with Java – http://www.cafeconleche.org/books/xmljava/
Archiwum kategorii: Java
Java ,Powtórka – Przydatne Linki
Java – Fraktale – Trójkąt Sierpińskiego.
Fraktale – Trójkąt Sierpińskiego .Implementacja w Javie.
Sierpiński Wacław, urodził się w 1882, zmarł w 1969, matematyk, jeden z twórców warszawskiej szkoły matematycznej, autor licznych prac z dziedziny teorii mnogości, teorii liczb, teorii funkcji rzeczywistych i topologii. Studiował na uniwersytecie w Warszawie, a następnie podjął pracę w szkolnictwie średnim. Przyłączywszy się do strajku szkolnego w 1905, porzucił tę pracę i wyjechał do Krakowa, gdzie się doktoryzował. Od 1910 był profesorem na uniwersytecie we Lwowie. Prowadzony tam przez Sierpińskiego wykład teorii mnogości był pierwszym w świecie systematycznym wykładem tej teorii. W czasie I wojny światowej Sierpiński był internowany w Rosji przez władze carskie. W 1918 powrócił do Lwowa, a od nowego roku akademickiego 1918/19 objął katedrę matematyki w odrodzonym po latach niewoli Uniwersytecie Warszawskim (UW). W 1920—51 Sierpiński wraz z S. Mazurkiewiczem (do 1945), następnie z K. Kuratowskim pełnił funkcję redaktora naczelnego polskiego czasopisma matematycznego „Fundamenta Mathematicae”. Był inicjatorem Pierwszego Kongresu Matematyków Krajów Słowiańskich, który odbył się w 1929 w Warszawie; reprezentował matematykę polską na sześciu kongresach międzynarodowych. W 1931 — 51 był prezesem Towarzystwa Naukowego Warszawskiego. W okresie okupacji hitlerowskiej wykładał na tajnym uniwersytecie, nie przerywając pracy naukowej. W 1945, po krótkim pobycie na Uniwersytecie Jagiellońskim, powrócił na UW i kontynuował działalność naukową oraz dydaktyczną. W 1958—69 był redaktorem naczelnym wznowionego czasopisma polskiego „Acta Arithmetica”, jedynego wówczas na świecie czasopisma poświęconego głównie teorii liczb. W czasie niezwykle aktywnego życia Sierpiński wykładał na 47 uniwersytetach świata i wykształcił kilka pokoleń matematyków. Jego imieniem nazwano jedną z nagród Polskiego Towarzystwa Matematycznego. Dorobek naukowy Sierpińskiego obejmuje około 900 publikacji, w tym kilkadziesiąt książek, m. in. monografie, podręczniki akademickie, podręczniki szkolne, książeczki popularnonaukowe (kilka ważnych dzieł ukazało się tylko w językach obcych). Pierwsze prace Sierpińskiego dotyczyły teorii liczb. Później (1909) skierował Sierpiński zainteresowania ku teorii mnogości, przyczyniając się do przekształcenia tej dyscypliny matematycznej w usystematyzowaną teorię. Zajmował się głównie aksjomatem wyboru, hipotezą continuum, a także arytmetyką liczb kardynalnych i liczb porządkowych. Niektóre prace Sierpińskiego były poświęcone zagadnieniu przystawania przez rozkład i rozkładom paradoksalnym. W topologii znana jest krzywa Sierpińskiego, zwana także -dywanem Sierpińskiego. Wyniki Sierpińskiego w zakresie funkcji rzeczywistych dotyczą m. in. szeregów funkcyjnych i różniczkowalności funkcji. Sierpiński jest autorem takich książek, jak: Teoria liczb niewymiernych (1910), Teoria liczb (1914), Zarys teorii mnogości, część l Liczby pozaskończone (1923), część 2 Topologia ogólna (1928), Wstęp do teorii mnogości i topologii (1930), Wstęp do teorii funkcji zmiennej rzeczywistej (1932), Wstęp do teorii liczb (1933), Przekroje. Wstęp do teorii liczb niewymiernych (1934), Zasady algebry wyższej (1946), Trójkąty pitagorejskie (1954), Arytmetyka teoretyczna (1955), O rozwiązywaniu równań w liczbach całkowitych (1956), Czym się zajmuje teoria liczb (1957), O rozkładach liczb wymiernych na ułamki proste (1957), O stu prostych, ale trudnych zagadnieniach arytmetyki, z pogranicza geometrii i arytmetyki (1959), Teoria liczb (część 2 1959), Co wiemy, a czego nie wiem v o liczbach pierwszych (1961), Liczby trójkątne (1962), 200 zadań z elementarnej teorii liczb (1964), O teorii mnogości (1964).
Implementacja w Javie.
import java.applet.*;
import java.awt.*;
public class Sierpinski extends Applet {
Graphics g;
Point a1,b1,c1, a2,b2,c2, a3,b3,c3;
int level = 0;
public void init() {
setBackground(new Color(255,255,255));
}
public boolean mouseDown(Event ev, int x, int y) {
if (!ev.metaDown()) level += 1;
else if (level>0) level -= 1;
repaint();
return true;
}
public void paint(Graphics g) {
int xCoords[] = {10, 390, 200};
int yCoords[] = {390, 390, 10};
g.drawPolygon(xCoords, yCoords, 3);
drawTriangle(g, new Point(10,390),new Point(390,390),new Point(200,10), level);
}
public void drawTriangle(Graphics g, Point a, Point b, Point c, int level) {
if (level==0) return;
level -= 1;
int xCoords[] = {c.x, (c.x+b.x)/2, (a.x+c.x)/2};
int yCoords[] = {b.y, (c.y+a.y)/2, (c.y+a.y)/2};
g.drawPolygon(xCoords, yCoords, 3);
a1 = a;
b1 = new Point(c.x, b.y);
c1 = new Point((a.x+c.x)/2, (c.y+a.y)/2);
drawTriangle(g, a1, b1, c1, level);
a2 = new Point(c.x, b.y);
b2 = b;
c2 = new Point((c.x+b.x)/2, (c.y+a.y)/2);
drawTriangle(g, a2, b2, c2, level);
a3 = new Point((a.x+c.x)/2, (c.y+a.y)/2);
b3 = new Point((c.x+b.x)/2, (c.y+a.y)/2);
c3 = c;
drawTriangle(g, a3, b3, c3, level);
}
}
Wynik:
Java – Wprowadzenie Do Liczb Rzymskich
Tekst (opis) ten pochodzi z wikipedi.pl – implementacja w Javie już nie. Dokończenie mojego posta
"Java – Zadania Testowe " z Marca 2008
Najprawdopodobniej spotkaliśmy się już gdzieś z liczbami rzymskimi. Można je spotkać w starszych filmach oglądanych w telewizji (np. "Copyright MCMXLVI" zamiast "-Copyright 1946") lub na ścianach bibliotek, czy uniwersytetów (napisy typu "założone w MDCCCLXXXVIII" zamiast "założone w 1888 roku"). Mogliśmy je także zobaczyć na przykład w referencjach bibliograficznych. Ten system reprezentowania liczb sięga czasów starożytnego Rzymu
W liczbach rzymskich wykorzystuje się siedem znaków, które na różne sposoby się powtarza i łączy, aby zapisać pewną liczbę:
- I = 1
- V = 5
- X = 10
- L = 50
- C = 100
- D = 500
- M = 1000
Poniżej znajdują się podstawowe zasady konstruowania liczb rzymskich:
- Znaki są addytywne. I to 1, II to 2, a III to 3. VI to 6 (dosłownie, „5 i 1”), VII to 7, a VIII to 8.
- Znaki dziesiątek (I, X, C i M) mogą się powtarzać do trzech razy. Za czwartym należy odjąć od następnego większego znaku piątek. Nie można zapisać liczby 4 jako IIII. Zamiast tego napiszemy IV ("o 1 mniej niż 5"). Liczba 40 zapisujemy jako XL (o 10 mniej niż 50), 41 jako XLI, 42 jako XLII, 43 jako XLIII, a potem 44 jako XLIV (o 10 mniej niż 50, a potem o 1 mniej niż 5).
- Podobnie w przypadku 9. Musimy odejmować od wyższego znaku dziesiątek: 8 to VIII, lecz 9 zapiszemy jako IX (o 1 mniej niż 10), a nie jako VIIII (ponieważ znak nie może się powtarzać cztery razy). Liczba 90 to XC, a 900 zapiszemy jako CM.
- Znaki piątek nie mogą się powtarzać. Liczba 10 jest zawsze reprezentowana przez X, nigdy przez VV. Liczba 100 to zawsze C, nigdy LL.
- Liczby rzymskie są zawsze pisane od najwyższych do najniższych i czytane od lewej do prawej, więc porządek znaków jest bardzo ważny. DC to 600, jednak CD jest kompletnie inną liczbą (400, ponieważ o 100 mniej niż 500). CI to 101, jednak IC nie jest żadną poprawną liczbą rzymską (nie możemy bezpośrednio odejmować 1 od 100, musimy to zapisać jako XCIX, o 10 mniej niż 100, dodać 1 mniej niż 10).{mospagebreak}
Zasady tworzenia liczb rzymskich prowadzą do kilku interesujących obserwacji:
- Istnieje tylko jeden poprawny sposób reprezentowania pewnej liczby w postaci rzymskiej.
- Odwrotność też jest prawdą: jeśli ciąg znaków jest poprawną liczbą rzymską, to reprezentuje ona tylko jedną liczbę (tzn. możemy ją przeczytać tylko w jeden sposób).
- Tylko ograniczony zakres liczb może być zapisany jako liczby rzymskie, a dokładniej liczby od 1 do 3999 (Liczby rzymskiej posiadają kilka sposobów wyrażania większych liczb np. poprzez dodanie nadkreślenia nad cyframi rzymskimi, co oznacza, że normalną wartość tej liczby trzeba pomnożyć przez 1000, jednak nie będziemy się wdawać w szczegóły. Dla potrzeb tego rozdziału, założymy, że liczby rzymskie idą od 1 do 3999).
- Nie mamy możliwość zapisania 0 jako liczby rzymskiej. (Co ciekawe, starożytni Rzymianie nie wyobrażali sobie 0 jako liczby. Za pomocą liczb liczymy, ile czegoś mamy, jednak jak możemy policzyć coś, czego nie mamy?)
- Nie możemy w postaci liczby rzymskiej zapisać liczby ujemnej.
- W postaci liczby rzymskiej nie możemy zapisywać ułamków, czy liczb, które nie są całkowite.
Biorąc to wszystko pod uwagę, co możemy oczekiwać od zbioru funkcji, które konwertują z i na liczby rzymskie? Wymagania RomanNumeral.java
- RomanNumeral.java powinien zwracać rzymską reprezentację wszystkich liczb całkowitych z zakresu od 1 do 3999.
- RomanNumeral.java powinien nie zadziałać (ang. fail ), gdy otrzyma liczbę całkowitą z poza przedziału od 1 do 3999.
- RomanNumeral.java powinien nie zadziałać, gdy otrzyma niecałkowitą liczbę.
- RomanNumeral.java powinien zawsze zwrócić liczbę rzymską korzystając z wielkich liter lub małych liter.
/*******************************************************************************************************
* @(#)RomanNumeral.java
*
* RomanNumeral application
*
* @author Andre W
* @version 1.00 2008
*******************************************************************************************************/
public class RomanNumeral
{
private String _value;
private int _intValue;
public RomanNumeral(int number)
{
_intValue = number;
_value = evaluate(_intValue);
}
public int getIntValue()
{
return _intValue;
}
public String toString()
{
return this._value;
}
public String getValue()
{
return this._value;
}
public String getLowerCaseValue()
{
return this._value.toLowerCase();
}
public static String evaluate(int value)
{
StringBuffer ret = new StringBuffer();
value = doThousands(value, ret);
value = doHundreds(value, ret);
value = doTens(value, ret);
doOnes(value, ret);
return ret.toString();
}
private static int doThousands(int value, StringBuffer buff)
{
int ret = value;
int subtract = 0;
while (value >= 900)
{
if(value >= 1000)
{
buff.append("M");
subtract += 1000;
value -= 1000;
}
else if(value >= 900)
{
buff.append("CM");
subtract += 900;
value -= 900;
}
}
return ret - subtract;
}
private static int doHundreds(int value, StringBuffer buff)
{
int ret = value;
int subtract = 0;
while (value >= 90)
{
if(value >= 500)
{
buff.append("D");
subtract += 500;
value -= 500;
}
else if(value >= 400)
{
buff.append("CD");
subtract += 400;
value -= 400;
}
else if(value >= 100)
{
buff.append("C");
subtract += 100;
value -= 100;
}
else if(value >= 90)
{
buff.append("XC");
subtract += 90;
value -= 90;
}
}
return ret - subtract;
}
private static int doTens(int value, StringBuffer buff)
{
int ret = value;
int subtract = 0;
while (value >= 9)
{
if(value >= 50)
{
buff.append("L");
subtract += 50;
value -= 50;
}
if(value >= 40)
{
buff.append("XL");
subtract += 40;
value -= 40;
}
else if(value >= 10)
{
buff.append("X");
subtract += 10;
value -= 10;
}
else if(value == 9)
{
buff.append("IX");
subtract += 9;
value -= 9;
}
}
return ret - subtract;
}
private static void doOnes(int value, StringBuffer buff)
{
while (value > 0)
{
if(value >= 5)
{
buff.append("V");
value -= 5;
}
else if(value == 4)
{
buff.append("IV");
value -= 4;
}
else if(value < 4)
{
buff.append("I");
value -= 1;
}
}
}
public static void main(String[] args)
{
for(int x = 1; x <= 3999; x++)
{
RomanNumeral rn = new RomanNumeral(x);
System.out.println("Int value: " + rn.getIntValue() + " = " + rn.toString() + " or " + rn.getLowerCaseValue());
}
}
}
