Thinking in Java, 4th Edition (полная версия)
Всем добрый день,
Задался вопросом: есть ли где-то эта книга на русском языке и в полном обьеме?
Потому что из моих сравнений оригинальной и русской версии — последняя не полная и даже попадаются ошибки. Спасибо!
P.S. знаю что лучше читать на английском, но все же:)
Именно. Для технических книг редко существует стопиццот разных переводов.
Нет ее в полном объёме на русском, т.е. как перевел «Питер» с потерями, так и есть. Читай оригинал
то не «потери», а просто перевод первой редакции. 4е издание выходило в нескольких редакциях, первая — как-раз то, где на ~400 стр меньше чем в
3-ей... в общем, ту самую 3ю редакцию и на нэйтиве найти очень сложно. Первое издание вот этим дополнить можете «Annotated Solution Guide for Thinking in Java» это просто решебник так сказать
А вообще, по актуальной жабе вот эти рулят:
1. Core Java
— www.amazon.com/...s/dp/0137081898
— www.amazon.com/...s/dp/013708160X
2. Java The Complete Reference 9/E
https://habr.com/en/post/212707/ И по ссылке разбор ошибок в переводе этой книги.
Советуют так : Для начала прочитайте бессмертную книгу "Thinking in Java".
Потом сходите на собеседования в пару компаний, там все и узнаете. Честно предупреждайте, что хотите работать Java junior, Вам все должны будут рассказать. Просто прочитать и сходить. Не верю в это.
Но я начну с консоли линукса.
Код выглядит так :
//Листинг 2.1. Программа array.java
// array.java
// Работа с массивами Java
// Запуск программы: C>java arrayApp
////////////////////////////////////////////////////////////////
class ArrayApp
{
public static void main(String[] args)
{
long[] arr;
// Ссылка на массив
Листинг 2.1 (продолжение)
arr = new long[100];
// Создание массива
int nElems = 0;
// Количество элементов
int j;
// Счетчик цикла
long searchKey;
// Ключи искомого элемента
//--------------------------------------------------------------
arr[0] = 77;
// Вставка 10 элементов
arr[1] = 99;
arr[2] = 44;
arr[3] = 55;
arr[4] = 22;
arr[5] = 88;
arr[6] = 11;
arr[7] = 00;
arr[8] = 66;
arr[9] = 33;
nElems = 10;
// Массив содержит 10 элементов
//--------------------------------------------------------------
for(j=0; j<nElems; j++)
// Вывод элементов
System.out.print(arr[j] + " ");
System.out.println("");
//--------------------------------------------------------------
searchKey = 66;
// Поиск элемента с ключом 66
for(j=0; j<nElems; j++)
// Для каждого элемента
if(arr[j] == searchKey)
// Значение найдено?
break;
// Да - выход из цикла
if(j == nElems)
// Достигнут последний элемент?
System.out.println("Can't find " + searchKey); // Да Пн 18 мар 2019 16:03:27
else
System.out.println("Found " + searchKey);
// Нет
//--------------------------------------------------------------
searchKey = 55;
// Удаление элемента с ключом 55
for(j=0; j<nElems; j++)
// Поиск удаляемого элемента
if(arr[j] == searchKey)
break;
for(int k=j; k<nElems-1; k++)
// Сдвиг последующих элементов
arr[k] = arr[k+1];
nElems--;
// Уменьшение размера
//--------------------------------------------------------------
for(j=0; j<nElems; j++)
// Вывод элементов
System.out.print( arr[j] + " ");
System.out.println("");
}
}
// Конец класса ArrayApp
/*Программа создает массив с именем arr , помещает в него 10 элементов данных
(номера игроков), ищет элемент с ключом 66, выводит все элементы, удаляет игро-
ка с ключом 55 и выводит оставшиеся 9 элементов. Результат работы программы
выглядит так:Поддержка массивов в Java
55
77 99 44 55 22 88 11 0 66 33
Found 66
77 99 44 22 88 11 0 66 33 */
У меня в блокноте всё красиво раскрашено. ( настройки его несложные ).
Кстати ошибок нет. Мною проверено сегодня Пн 18 мар 2019 18:35:49 И календарь даже раскрашен. И зачем ?
Проверяем что установлено на моём компьютере
$ java -version
java version "1.8.0_201"
Java(TM) SE Runtime Environment (build 1.8.0_201-b09)
Java HotSpot(TM) 64-Bit Server VM (build 25.201-b09, mixed mode)
alex@alex:~/Emacsjava/Reese/chapter2_1/bin$
Всё.
Так как есть ещё время и силы рассмотрю дальше проект уже с 4 файлами, тоже массив.
Предыдущий был в процедурном стиле, а следующий в объектно-ориентированном. В чем разница ?
Холивары на эту тему ведутся всё время.
http://artanovy.com/2011/03/procedurnoe-protiv-obyektno-orientirovannogo/
Процедурное против объектно-ориентированного?
https://www.internet-technologies.ru/articles/chetyre-principa-obektno-orientirovannogo-programmirovaniya-v-java.html
Эта статья станет шпаргалкой по четырем основам ООП (инкапсуляции, наследованию, полиморфизму и абстракции).
Но это не религия, немало программистов работают с классами не ведая об этих четырех классах ни ухом, ни рылом.
Да, а вот здесь уже 7 основ. http://codengineering.ru/post/21 Кто-то называет это прозрением.
А кто-то вставляет палки в колёса.
ArrayList figures = new ArrayList(); - правильно будет в данном случае List<point> figures = new ArrayList<>();
ArrayList - Это специальная структура данных в java, позволяющая хранить объекты определенного типа в массиве. - неверное утверждение. Правильно будет в данном случае: ArrayList - это одна из реализаций интерфейса List(список) за основу которой берётся обычный массив.
/**
* Пустой конструктор
*/
Point() {}
Пустой конструктор будет создан по умолчанию, не нужно им захламлять код.
P.S. Почему-то имя класса Point приводится к нижнем регистру автоматом в комментарии.
Кстати https://hyyudu.livejournal.com/225543.html Объектно-ориентированное программирование (ООП) - одна из парадигм, моделей написания программ. Их вообще есть еще несколько - функциональное, логическое, императивное ака процедурное и т.д. Если захотите - в Випипедии найдете. Наш же рассказ пойдет в особенности про хоббитов. Точнее, про объекты.
Добавлю, что на эту тему написано много. Возможно, что в ООП проще вносить изменения при необходимости.
Вт 19 мар 2019 17:40:12
//Листинг 2.5. Программа classDataArray.java
// classDataArray.java
// Объекты как элементы данных
// Запуск программы: C> java ClassDataApp
////////////////////////////////////////////////////////////////
class Person
{
private String lastName;
private String firstName;
private int age;
//--------------------------------------------------------------
public Person(String last, String first, int a)
{
// Конструктор
lastName = last;
firstName = first;
age = a;
}
//--------------------------------------------------------------
public void displayPerson()
{
System.out.print("Last name:" + lastName);
System.out.print(", First name: " + firstName);
System.out.println(", Age: " + age);
}
//--------------------------------------------------------------
public String getLast()
// Получение фамилии
{ return lastName; }
} // Конец класса PersonХранение объектов
// page 77
////////////////////////////////////////////////////////////////
class ClassDataArray
{
private Person[] a;
// Ссылка на массив
private int nElems;
// Количество элементов данных
public ClassDataArray(int max)
// Конструктор
{
a = new Person[max];
// Создание массива
nElems = 0;
// Пока нет ни одного элемента
}
//--------------------------------------------------------------
public Person find(String searchName)
{
// Поиск заданного значения
int j;
for(j=0; j<nElems; j++)
// Для каждого элемента
if( a[j].getLast().equals(searchName) ) // Значение найдено?
break;
// Выход из цикла
if(j == nElems)
// Достигнут последний элемент?
return null;
// Да, значение не найдено
else
return a[j];
// Нет, значение найдено
} // end find()
//-------------------------------------------------------------
// Включение записи в массив
public void insert(String last, String first, int age)
{
a[nElems] = new Person(last, first, age);
nElems++;
// Увеличение размера
}
//--------------------------------------------------------------
public boolean delete(String searchName)
{
// Удаление из массива
int j;
for(j=0; j<nElems; j++)
// Поиск удаляемого элемента
if( a[j].getLast().equals(searchName) )
break;
if(j==nElems)
// Найти не удалось
return false;
else
// Значение найдено
{
for(int k=j; k<nElems; k++)
// Сдвиг последующих элементов
a[k] = a[k+1];
nElems--;
// Уменьшение размера
return true;
}
}
//продолжение 78 Глава 2. Массивы
//Листинг 2.5 (продолжение)
//--------------------------------------------------------------
public void displayA()
// Вывод содержимого массива
{
for(int j=0; j<nElems; j++)
// Для каждого элемента
a[j].displayPerson();
// Вывод
}
//--------------------------------------------------------------
} // Конец класса ClassDataArray
////////////////////////////////////////////////////////////////
class ClassDataApp
{
public static void main(String[] args)
{
int maxSize = 100;
// Размер массива
ClassDataArray arr;
// Ссылка на массив
arr = new ClassDataArray(maxSize); // Создание массива
// Вставка 10 элементов
arr.insert("Evans", "Patty", 24);
arr.insert("Smith", "Lorraine", 37);
arr.insert("Yee", "Tom", 43);
arr.insert("Adams", "Henry", 63);
arr.insert("Hashimoto", "Sato", 21);
arr.insert("Stimson", "Henry", 29);
arr.insert("Velasquez", "Jose", 72);
arr.insert("Lamarque", "Henry", 54);
arr.insert("Vang", "Minh", 22);
arr.insert("Creswell", "Lucinda", 18);
arr.displayA();
// Вывод содержимого
String searchKey = "Stimson"; // Поиск элемента
Person found;
found=arr.find(searchKey);
if (found != null)
{
System.out.print("Found ");
found.displayPerson();
}
else
System.out.println("Can't find " + searchKey);
System.out.println("Deleting Smith, Yee, and Creswell");
arr.delete("Smith");
// Удаление трех элементов
arr.delete("Yee");
arr.delete("Creswell");
arr.displayA();
// Повторный вывод содержимого
}
} // Конец класса ClassDataApp
////////////////////////////////////////////////////////////////
/*page 79 Класс Person Lafore 2013
Результат выполнения программы:
Last name: Evans, First name: Patty, Age: 24
Last name: Smith, First name: Lorraine, Age: 37
Last name: Yee, First name: Tom, Age: 43
Last name: Adams, First name: Henry, Age: 63
Last name: Hashimoto, First name: Sato, Age: 21
Last name: Stimson, First name: Henry, Age: 29
Last name: Velasquez, First name: Jose, Age: 72
Last name: Lamarque, First name: Henry, Age: 54
Last name: Vang, First name: Minh, Age: 22
Last name: Creswell, First name: Lucinda, Age: 18
Found
Last name: Stimson, First name: Henry, Age: 29
Deleting Smith, Yee, and Creswell
Last name: Evans, First name: Patty, Age: 24
Last name: Adams, First name: Henry, Age: 63
Last name: Hashimoto, First name: Sato, Age: 21
Last name: Stimson, First name: Henry, Age: 29
Last name: Velasquez, First name: Jose, Age: 72
Last name: Lamarque, First name: Henry, Age: 54
Last name: Vang, First name: Minh, Age: 22
Программа classDataArray.java наглядно показывает, что структуры данных
могут использоваться не только для хранения примитивных типов, но и объектов
классов. (Обратите внимание: реальная программа, использующая фамилию в ка-
честве ключа, должна принять во внимание возможность дублирования фамилий —
как упоминалось ранее, это несколько усложнит программирование.)
O-синтаксис
В США автомобили делятся в зависимости от размера на несколько категорий:
субкомпакты, компакты, среднеразмерные и т. д. Эти категории позволяют по-
лучить общее представление о габаритах автомобиля без указания конкретных
размеров. Подобная система приблизительных обозначений существует и для
описания эффективности компьютерных алгоритмов. В информатике она назы-
вается «O-синтаксисом».
На первый взгляд может показаться, что сравнение алгоритмов должно бази-
роваться на оценках вида «Алгоритм А работает вдвое быстрее алгоритма Б», но
в действительности такие утверждения не имеют особого смысла. Почему? Потому
что пропорции могут кардинально изменяться при изменении количества элемен-
тов. Допустим, при увеличении количества элементов на 50% алгоритм А начинает
работать втрое быстрее алгоритма Б, а при половинном количестве элементов
алгоритмы А и Б сравниваются по скорости. Критерий сравнения (сложность ал
горитма) должен связывать скорость алгоритма с количеством элементов. Давайте
проанализируем эту связь для алгоритмов, рассмотренных ранее.
Специальный выпуск для Лены.
O-синтаксис Page 83
*/
Какой вывод, не углубляясь в объяснение на примерах ( Дом, Машина, Животные и т. д. )эти примеры не помогают. А вот здесь видно что, для начала при сравнении двух файлов. Из них первый без классов, а
второй с классами. Во второй программе мы видим слова классы ( classes ), а в первой нет.
В этой папке даем команду : $ javac classDataArray.java
В той папке где лежит один java файл, classDataArray.java появятся ClassDataApp.class , ClassDataApp.class,
Person.class ( то есть три файла с расширением .class ) Readmy я создаю сам для комментария. В этой же папке
выполняем программу с помощью $ java ClassDataApp
и видим результат :
alex@alex:~/Emacsjava/Reese/Listing_2_5$ java ClassDataApp
Last name:Evans, First name: Patty, Age: 24
Last name:Smith, First name: Lorraine, Age: 37
Last name:Yee, First name: Tom, Age: 43
Last name:Adams, First name: Henry, Age: 63
Last name:Hashimoto, First name: Sato, Age: 21
Last name:Stimson, First name: Henry, Age: 29
Last name:Velasquez, First name: Jose, Age: 72
Last name:Lamarque, First name: Henry, Age: 54
Last name:Vang, First name: Minh, Age: 22
Last name:Creswell, First name: Lucinda, Age: 18
Found Last name:Stimson, First name: Henry, Age: 29
Deleting Smith, Yee, and Creswell
Last name:Evans, First name: Patty, Age: 24
Last name:Adams, First name: Henry, Age: 63
Last name:Hashimoto, First name: Sato, Age: 21
Last name:Stimson, First name: Henry, Age: 29
Last name:Velasquez, First name: Jose, Age: 72
Last name:Lamarque, First name: Henry, Age: 54
Last name:Vang, First name: Minh, Age: 22
alex@alex:~/Emacsjava/Reese/Listing_2_5$
Результат отличается от результата в первой программе. Неплохо, но не это главное.
При необходимости можно в пределах класса менять что-то. Проще, чем в первом файле.
И ещё одна сегодня, тоже с одним файлом и несколькими классами
Только что выполнилась.
//554 Глава 12. Пирамиды
/*Размер массива
Размер массива (количество узлов в пирамиде) — важнейший атрибут состояния
пирамиды и необходимое поле класса Heap . Узлы, скопированные из последней
ячейки, не стираются, поэтому алгоритм может определить положение последней
занятой ячейки только по текущему размеру массива.
Программа heap.java
В программе heap.java (листинг 12.1) используется класс Node . Единственным по-
лем этого класса является переменная iData , в которой хранится ключ узла. Есте-
ственно, в реальной программе этот класс содержал бы много других полей. Класс
Heap содержит методы, упомянутые выше, а также методы isEmpty() и displayHeap() .
Последний метод выводит примитивное, но наглядное символьное представление
содержимого пирамиды.
Листинг 12.1. Программа heap.java
*/
// heap.java
// Работа с пирамидой
// Запуск программы: C>java HeapApp
import java.io.*;
////////////////////////////////////////////////////////////////
class Node
{
private int iData;
// Данные (ключ)
// -------------------------------------------------------------
public Node(int key)
// Конструктор
{ iData = key; }
// -------------------------------------------------------------
public int getKey()
{ return iData; }
// -------------------------------------------------------------
public void setKey(int id)
{ iData = id; }
// -------------------------------------------------------------
} // Конец класса Node
////////////////////////////////////////////////////////////////
class Heap
{
private Node[] heapArray;
private int maxSize;
// Размер массива
private int currentSize;
// Количество узлов в массиве
// -------------------------------------------------------------
public Heap(int mx)
// Конструктор
{
maxSize = mx;
currentSize = 0;
// Реализация пирамиды на языке Java
//
//
//
//
//
// page 555
heapArray = new Node[maxSize];
// Создание массива
}
// -------------------------------------------------------------
public boolean isEmpty()
{ return currentSize==0; }
// -------------------------------------------------------------
public boolean insert(int key)
{
if(currentSize==maxSize)
return false;
Node newNode = new Node(key);
heapArray[currentSize] = newNode;
trickleUp(currentSize++);
return true;
}
// -------------------------------------------------------------
public void trickleUp(int index)
{
int parent = (index-1) / 2;
Node bottom = heapArray[index];
while( index > 0 &&
heapArray[parent].getKey() < bottom.getKey() )
{
heapArray[index] = heapArray[parent]; // Узел смещается вниз
index = parent;
parent = (parent-1) / 2;
}
heapArray[index] = bottom;
}
// -------------------------------------------------------------
public Node remove()
// Удаление элемента с наибольшим ключом
{
// (Предполагается, что список не пуст)
Node root = heapArray[0];
heapArray[0] = heapArray[--currentSize];
trickleDown(0);
return root;
}
//-------------------------------------------------------------
public void trickleDown(int index)
{
int largerChild;
Node top = heapArray[index];
// Сохранение корня
while(index < currentSize/2)
// Пока у узла имеется
{
// хотя бы один потомок
int leftChild = 2*index+1;
int rightChild = leftChild+1;
// Определение большего потомка
if(rightChild < currentSize && // (Правый потомок существует?)
heapArray[leftChild].getKey() <
// продолжение 556 Глава 12. Пирамиды
// Листинг 12.1 (продолжение)
heapArray[rightChild].getKey())
largerChild = rightChild;
else
largerChild = leftChild;
// top >= largerChild?
if( top.getKey() >= heapArray[largerChild].getKey() )
break;
// Потомок сдвигается вверх
heapArray[index] = heapArray[largerChild];
index = largerChild;
// Переход вниз
}
heapArray[index] = top;
// index <- корень
}
// -------------------------------------------------------------
public boolean change(int index, int newValue)
{
if(index<0 || index>=currentSize)
return false;
int oldValue = heapArray[index].getKey(); // Сохранение старого ключа
heapArray[index].setKey(newValue); // Присваивание нового ключа
if(oldValue < newValue)
// Если узел повышается,
trickleUp(index);
// выполняется смещение вверх.
else
// Если узел понижается,
trickleDown(index);
// выполняется смещение вниз.
return true;
}
// -------------------------------------------------------------
public void displayHeap()
{
System.out.print("heapArray: ");
// Формат массива
for(int m=0; m<currentSize; m++)
if(heapArray[m] != null)
System.out.print( heapArray[m].getKey() + " ");
else
System.out.print( "-- ");
System.out.println();
// Формат пирамиды
int nBlanks = 32;
int itemsPerRow = 1;
int column = 0;
int j = 0;
// Текущий элемент
String dots = "...............................";
System.out.println(dots+dots);
// Верхний пунктир
while(currentSize > 0)
{
if(column == 0)
for(int k=0; k<nBlanks; k++)
// Для каждого элемента пирамиды
// Первый элемент в строке?
// Предшествующие пробелыРеализация пирамиды на языке Java
// 557
System.out.print("");
// Вывод элемента
System.out.print(heapArray[j].getKey());if(++j == currentSize)
// Вывод завершен?
break;
if(++column==itemsPerRow)
// Конец строки?
{
nBlanks /= 2;
// Половина пробелов
itemsPerRow *= 2;
// Вдвое больше элементов
column = 0;
// Начать заново
System.out.println();
// Переход на новую строку
}
else
// Следующий элемент в строке
for(int k=0; k<nBlanks*2-2; k++)
//System.out.print(‘ ‘);
//Здесь ошибка, я просто переписал строку в консоли (видно, что ' ' разные)
System.out.print(' ');
// Внутренние пробелы
}
System.out.println("\n"+dots+dots);
// Нижний пунктир
}
// -------------------------------------------------------------
}
// Конец класса Heap
////////////////////////////////////////////////////////////////
class HeapApp
{
public static void main(String[] args) throws IOException
{
int value, value2;
Heap theHeap = new Heap(31); // Создание пирамиды с максимальным
boolean success;
// размером 31
theHeap.insert(70);
theHeap.insert(40);
theHeap.insert(50);
theHeap.insert(20);
theHeap.insert(60);
theHeap.insert(100);
theHeap.insert(80);
theHeap.insert(30);
theHeap.insert(10);
theHeap.insert(90);
// Вставка 10 items
while(true)
// Пока пользователь не нажмет Ctrl+C
{
System.out.print("Enter first letter of ");
System.out.print("show, insert, remove, change: ");
int choice = getChar();
switch(choice)
{
case 's':
// Вывод
// продолжение 558 Глава 12. Пирамиды
// Листинг 12.1 (продолжение)
theHeap.displayHeap();
break;
case 'i':
// Вставка
System.out.print("Enter value to insert: ");
value = getInt();
success = theHeap.insert(value);
if( !success )
System.out.println("Can’t insert; heap full");
break;
case 'r':
// Удаление
if( !theHeap.isEmpty() )
theHeap.remove();
else
System.out.println("Can’t remove; heap empty");
break;
case 'c':
// Изменение приоритета
System.out.print("Enter current index of item: ");
value = getInt();
System.out.print("Enter new key: ");
value2 = getInt();
success = theHeap.change(value, value2);
if( !success )
System.out.println("Invalid index");
break;
default:
System.out.println("Invalid entry\n");
}
}
}
//-------------------------------------------------------------
public static String getString() throws IOException
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}
//-------------------------------------------------------------
public static char getChar() throws IOException
{
String s = getString();
return s.charAt(0);
}
//-------------------------------------------------------------
public static int getInt() throws IOException
{
String s = getString();
return Integer.parseInt(s);
// Реализация пирамиды на языке Java
// page 559
}
//-------------------------------------------------------------
}
// Конец класса HeapApp
////////////////////////////////////////////////////////////////
/*
В массиве корень пирамиды размещается в ячейке с индексом 0. Некоторые
реализации пирамиды размещают корень в ячейке 1, а ячейка 0 используется в ка-
честве «сторожа» с наибольшим возможным ключом. Такое решение немного уско-
ряет некоторые алгоритмы, но усложняет реализацию на концептуальном уровне.
Метод main() приложения HeapApp
создает пирамиду с максимальным размером 31 (обусловленным ограничениями метода вывода) и вставляет в нее 10 узлов со
случайными ключами. Затем программа входит в цикл, в котором пользователь вводит команды s, i, r или c (соответственно вывод, вставка, удаление или изменение).
Пример взаимодействия с программой:
Enter first letter of show, insert, remove, change: s
heapArray: 100 90 80 30 60 50 70 20 10 40
..............................................................
100
90
80
30
60
50
70
20
10
40
..............................................................
Enter first letter of show, insert, remove, change: i
Enter value to insert: 53
Enter first letter of show, insert, remove, change: s
heapArray: 100 90 80 30 60 50 70 20 10 40 53
..............................................................
100
90
80
30
60
50
70
20
10
40
53
..............................................................
Enter first letter of show, insert, remove, change: r
Enter first letter of show, insert, remove, change: s
heapArray: 90 60 80 30 53 50 70 20 10 40
..............................................................
90
60
80
30
53
50
70
20
10
40
..............................................................
Enter first letter of show, insert, remove, change:
Пользователь выводит состояние пирамиды, добавляет элемент с ключом 53,
снова выводит, удаляет элемент с наибольшим ключом и выводит состояние
пирамиды в третий раз. Метод show() выводит оба представления пирамиды: как
в виде массива, так и в виде дерева. Сила воо
*/
// Выполнены те же команды, что и в предыдушей программе. Вт 19 мар 2019 20:46:21
Ср 20 мар 2019 22:15:38
Я здесь. Алгоритмы почти никому не нужны.
https://javarush.ru/groups/posts/1997-algoritmih-sortirovki-v-teorii-i-na-praktike
10 октября 2018 12:45
4249просмотров
4комментария
Алгоритмы сортировки в теории и на практике
Пост из группы Random далее отсюда ссылка на хабр ( часть 2 ).
https://habr.com/en/post/195482/
Введение в анализ сложности алгоритмов (часть 2)
https://habr.com/en/post/196560/
AveNat
October 7, 2013 at 02:12 PM
Введение в анализ сложности алгоритмов (часть 1)
http://discrete.gr/complexity/
Многие современные программисты, пишущие классные и широко распространённые программы, имеют крайне смутное представление о теоретической информатике. Это не мешает им оставаться прекрасными творческими специалистами, и мы благодарны за то, что они создают.
Тем не менее, знание теории тоже имеет свои преимущества и может оказаться весьма полезным. В этой статье, предназначенной для программистов, которые являются хорошими практиками, но имеют слабое представление о теории, я представлю один из наиболее прагматичных программистских инструментов: нотацию «большое О» и анализ сложности алгоритмов. Как человек, который работал как в области академической науки, так и над созданием коммерческого ПО, я считаю эти инструменты по-настоящему полезными на практике. Надеюсь, что после прочтения этой статьи вы сможете применить их к собственному коду, чтобы сделать его ещё лучше. Также этот пост принесёт с собой понимание таких общих терминов, используемых теоретиками информатики, как «большое О», «асимптотическое поведение», «анализ наиболее неблагоприятного случая» и т.п.
https://pandia.ru/text/78/339/550.php
Разработка алгоритмов простейших программ
https://habr.com/en/post/260713/
Это не столько IT, сколько R&D. Преобразование Фурье, с которого и начался функциональный анализ, широко используется во многих областях исследований. Например, спектральный анализ временных рядов. Это один из статистических методов анализа данных. Статистические методы — один из инструментов СППР.
Возможно, коллеги, работающие в этом направлении, приведут более детальные примеры.
Да, это мало кому действительно нужно на практике, но если у вас всё получается с этими предметами — вы понимаете, что хотите развиваться в R&D. Ср 20 мар 2019 22:15:38
Единицам, которые пишут нечто эпическое. Практики обходятся без знаний их.
22 марта 2018 Четверг
https://javatalks.ru/topics/20640
Проверено, у меня работает ( три файла ява и один readmy )
Давайте попробуем разобраться на этом примере: http://www.javatalks.ru/ftopic9059.php ?
вот я создал каталог PROBA, создал там три файла(Ball.java, BallComponent.java, BounceThread.java), в которые скопировал примеры кодов. Что мне дальше выполнять? Спрашивает человек.
1. создаем три исходника: Ball.java, BallComponent.java и BounceThread.java. положим их в какую-нибудь отдельную папку, например java
2. заходим в эту папку из командной строки (делаем ее текущей)
-
cd java
-
mkdir classes
-
javac -d ./classes *.java
-
cd classes
-
java -cp . BounceThread
опция -cp (classpath) говорит интерпретатору, где искать классы, требующиеся при выполнении метода main. classpath это также переменная окружения, можно задать в настройках командного интерпретатора, или командой CLASSPATH="$CLASSPATH:(your_path_to_classes)".. это в *nix, как в винде не помню. наслаждаемся летающими шариками!
Программируйте пока есть желание
// Ball.java
import java.awt.geom.*;
/**
* * A ball that moves and bounces off the edges of a
* * rectangle
* * @version 1.33 2007-05-17
* * @author Cay Horstmann
* */
public class Ball
{
/**
* Moves the ball to the next position, reversing direction
* if it hits one of the edges
* */
public void move(Rectangle2D bounds)
{
x += dx;
y += dy;
if (x < bounds.getMinX())
{
x = 2*bounds.getMinX() - x;
dx = -dx;
}
if (x + XSIZE >= bounds.getMaxX())
{
x = 2*(bounds.getMaxX() - XSIZE) - x;
dx = -dx;
}
if (y < bounds.getMinY())
{
y = 2*bounds.getMinY() - y;
dy = -dy;
}
if (y + YSIZE >= bounds.getMaxY())
{
y = 2*(bounds.getMaxY() - YSIZE) - y;
dy = -dy;
}
}
/**
* Gets the shape of the ball at its current position.
* */
public Ellipse2D getShape()
{
return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
}
private static final int XSIZE = 15;
private static final int YSIZE = 15;
private double x = 0;
private double y = 0;
private double dx = 1;
private double dy = 1;
}
---
// BallComponent.java
import java.awt.*;
import java.util.*;
import javax.swing.*;
/**
* * The component that draws the balls.
* * @version 1.33 2007-05-17
* * @author Cay Horstmann
* */
public class BallComponent extends JComponent
{
/**
* * Add a ball to the panel.
* * @param b the ball to add
* */
public void add(Ball b)
{
balls.add(b);
}
public void paintComponent(Graphics g)
{
Graphics2D g2 = (Graphics2D) g;
for (Ball b : balls)
{
g2.fill(b.getShape());
}
}
private ArrayList<Ball> balls = new ArrayList<Ball>();
}
---
// BounceThread.java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/**
* * Shows animated bouncing balls.
* * @version 1.33 2007-05-17
* * @author Cay Horstmann
* */
public class BounceThread
{
public static void main(String[] args)
{
JFrame frame = new BounceFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
/**
* * A runnable that animates a bouncing ball.
* */
class BallRunnable implements Runnable
{
/**
* * Constructs the runnable.
* * @aBall the ball to bounce
* * @aComponent the component in which the ball bounces
* */
public BallRunnable(Ball aBall, Component aComponent)
{
ball = aBall;
component = aComponent;
}
public void run()
{
try
{
for (int i = 1; i <= STEPS; i++)
&nb
