SimpleCoding.org » Java

Графики своими руками – Open Flash Chart 2

Владимир — Mon, 20 Apr 2009 16:21:36 +0000

Об этой библиотеке я раньше рассказывал (Open Flash Chart – строим графики). Но с тех пор прошло почти 8 месяцев и за это время многое изменилось.

Вышла новая версия библиотеки Open Flash Chart 2 и она довольно серьезно отличается от первой версии. Объяснять причины введения изменений я не буду, просто процитирую автора.

Open Flash Chart 1.x была отличной и хорошо работала. Но я сделал несколько маленьких ошибок, которые со временем выросли, стали раздражать меня и сделали исходный код жутким. Поэтому я решил, что настало время переработать код и снова сделать его красивым. Теперь в качестве формата данных используется JSON. Это привело к значительным изменениям и позволило реализовать несколько новых возможностей.

Выход новой версии не сделал V 1.x устаревшей. Вы можете использовать обе версии одновременно. Поэтому не трогайте ваш работающий с V 1.x код, а для новых графиков используйте ту версию которой вам удобнее (проще) пользоваться.

Думаю, ситуация более-менее ясна, поэтому сразу приведу пример использования второй версии.

Как и в первой версии нужно внимательно следить за размещением библиотеки и правильно указывать пути к файлам.

Структура сайта.

Допустим у нас есть домен http://localhost/

Библиотека находится в папке tests/ofc/lib/ и имеет такую структуру

tests/ofc/lib
	open-flash-chart.swf
	php-ofc-library/
		... (все файлы из папки php-ofc-library)

Примечание. Из дистрибутива я скопировал только флеш-ролик для создания графика и PHP версию библиотеки.

Страница, на которой мы будем показывать графики – http://localhost/tests/ofc/mygraphs.php.

Источники данных.

Данные можно брать откуда угодно, из базы, текстового файла, рассчитывать. Для этого примера мы создадим 2 php скрипта (data1.php и data2.php), которые будут формировать массивы с данными для построения графиков и преобразовывать их в формат JSON. Оба файла разместим в папке datasrc.

Т.к. источников данных у нас два, а график будет один, то нам нужно как-то указать какой из них необходимо использовать.

Имя скрипта – источника данных можно передать вместе с URL (в параметре ofc).

Т.е., на странице
http://localhost/tests/ofc/mygraphs.php?ofc=datasrc/data1.php
мы увидим график с данными сформированными скриптом data1.php.
А на странице
http://localhost/tests/ofc/mygraphs.php?ofc=datasrc/data2.php
график с данными из data2.php.

Обратите внимание. При указании источника данных мы указываем путь к файлу (относительно данной страницы).

Теперь рассмотрим сами скрипты.

mygraphs.php


'; ?>




	Open Flash Chart 2
	




Графики


	Первый график (data1.php)
	Второй график (data2.php)

Принцип работы здесь следующий. Сначала проверяем указан ли параметр ofc и если нет, отправляем посетителя на mygraphs.php?ofc=datasrc/data1.php. Т.е. на страницу с графиком, построенным по данным из скрипта data1.php.

На самой странице мы создаем список со ссылками на оба наших графика (строки 20-23) и размещаем flash ролик, с помощью которого и будет показан график (строки 25-43).

Код вставки ролика в основном остается без изменений. Нас, прежде всего, интересуют параметры width и height (задают размер графика в пикселях, строки 27, 28, 36, 37), id и align (строки 28, 39).

И, самое главное, атрибут value в параметре movie (строки 31 и 33). В нем указываем размещение ролика (lib/open-flash-chart.swf). Здесь также путь указан относительно данной страницы.

Теперь рассмотрим PHP скрипты, которые формируют данные для графиков.

data1.php

set_values($tmp);

$chart = new open_flash_chart();
$chart->set_title($title);
$chart->add_element($bar);

echo $chart->toString();

?>

Здесь мы загружаем библиотеку open-flash-chart.php (обратите внимание на то, как указано её размещение).

Затем формируем массив с данными $tmp (строки 4-8). Здесь я использовал не сложную функцию.

После этого создаём объект типа bar. Думаю, не сложно догадаться, что он используется для создания гистограмм. И с помощью метода set_values указываем массив с исходными данными.

Второй объект, который нам понадобиться – open_flash_chart. Его метод set_title используется для установки заголовка графика, а add_element – добавляет нашу гистограмму.

Последний шаг. Формируем строку в формате JSON с данными нашего графика (метод toString()).

Скрипт data2.php практически не отличается. Я только изменил функцию, формирующую массив с данными и тип графика.

data2.php

set_values($tmp);

$chart = new open_flash_chart();
$chart->set_title($title);
$chart->add_element($line);

echo $chart->toString();

?>

Как видите, принцип работы библиотеки достаточно простой. А на официальном сайте вы найдете множество других интересных примеров.

В заключение хочу сказать пару слов об эффективности этой библиотеки.

Т.к. картинка с графиком формируется на стороне клиента (с помощью Flash), то нагрузка на сервер будет минимальной. Получение данных и преобразование их в JSON формат потребует значительно меньше ресурсов, чем получение данных и создание графика, например, с помощью библиотеки GD.

Но в тоже время посетителю будет отправлен flash ролик (open-flash-chart.swf) объемом 264кБ. Для сравнения аналогичный png файл с изображением графика будет занимать 10-30кБ.

Отсюда простой вывод. Если ваше приложение напоминает Google Analytics, то с помощью Open Flash Chart вы не только снизите нагрузку на свой сервер, но и сэкономите трафик пользователей, т.к. flash ролик грузится только один раз. Но если вам нужно показать всего один или два графика, то вряд ли эта библиотека будет самым удачным выбором.

Если вы не согласны или хотите что-то спросить, не стесняйтесь, комментарии открыты

P.S. В следующий раз я продолжу тему графиков и расскажу об использовании сторонних сервисов для этих целей.

Интересно почитать

Аутсорсинг непрофильных операций. Логос-Аудит – ведение кадрового учёта для малого и среднего бизнеса.

Управление поиском файлов. Создание приложения на Java.

Владимир — Sun, 19 Aug 2007 14:47:05 +0000

Эта статья завершает цикл, посвящённый созданию библиотеки поиска файлов. На данный момент мы можем найти нужные файлы, и отсортировать их.
Теперь добавим возможности управления процессом поиска, получения промежуточных результатов, и напишем простейший поисковик с графическим интерфейсом.

Новые возможности
Итак, начнём. Прежде всего, вспомним, каким образом выполняется поиск в нашей библиотеке. Всё предельно просто. Для того чтобы найти файлы нужно вызвать один из методов find... класса FileFinder.

Проблема заключается в том, что продолжительность поиска может быть довольно большой, и, если мы просто вызовем метод find..., то работа программы будет заблокирована, пока он не возвратит результат. Это не играет роли в учебном примере, но если вашей программой будут пользоваться другие люди, такая ситуация недопустима. Конечно, пользователь услышит жужжание винчестера, но, скорее всего, ему не понравится, что программа внешне выглядит "зависнувшей".

Поэтому, нам нужно, чтобы поиск файлов выполнялся отдельно от основной программы (кода, который отвечает за работу интерфейса). Сделать это не сложно. Любая современная операционная система поддерживает многозадачность, и, естественно, в стандартную библиотеку Java входят классы для создания многопоточных (multithreaded) приложений. К сожалению, описание этих классов выходит далеко за рамки этой статьи, поэтому, если у вас возникнут вопросы, советую почитать: "Threads: Doing Two or More Tasks at Once", "Создание многопоточных приложений в Java" (на русском) или любую другую статью о создании многопоточных приложений.

Теперь поиск не будет блокировать работу программы, но кроме этого, хотелось бы знать о текущем состоянии процесса (например, сколько файлов найдено на данный момент). Для этого, наш класс FileFinder должен периодически передавать информацию о своем состоянии.

Тут возникает два вопроса: "Кому и как передавать информацию?". Ответы предельно просты: "Тому, кто её запросил. С помощью вызова соответствующих методов". Т.е. класс FileFinder должен содержать список объектов, которые следят за процессом поиска, и периодически вызывать нужные методы.

Естественно, все эти объекты должны иметь одинаковый тип. Тут очень удобно использовать интерфейсы. Если какой-нибудь класс, например, MainPanel реализует интерфейс SearchListener, то мы сможем привести объект типа MainPanel к типу SearchListener. Кроме того, MainPanel будет обязан реализовать все методы, объявленные в SearchListener.

Как видите, идея довольна простая. Теперь приступим к её реализации. В первую очередь я хочу показать, как будет выглядеть программа, использующая нашу библиотеку (рис.1). Как вы уже догадались, это простейшая программа поиска файлов. В верхнем текстовом поле нужно задать начальную папку поиска (можно использовать кнопку "Обзор"). В нижнем поле можно задать регулярное выражение (о правилах составления регулярных выражений, можно прочитать в статье "Анализ данных с помощью регулярных выражений или быстрый способ проверки введённых данных"). Если выражение задано, то в список результатов будут включены те файлы и папки, которые ему соответствуют. Кнопка "Поиск" запускает процесс поиска.

Рис.1. Программа поиска файлов

Во время поиска текст на кнопке "Поиск" изменяется на "Остановить", а напротив соответствующих надписей отображается информация о работе программы (рис.2).

Рис.2. Информация о текущих результатах

После завершения поиска, или если пользователь нажал на кнопку "Остановить", программа открывает окно с результатами (рис.3).

Рис.3. Результаты поиска

Программирование на Java. Сортировка списка файлов.

Владимир — Sat, 18 Aug 2007 19:16:13 +0000

В прошлой статье "Поиск файлов" мы начали разработку небольшой библиотеки для поиска файлов. На данный момент мы можем найти файлы, но не можем упорядочить результаты поиска. В этой статье я покажу, как создать класс, который позволит сортировать список файлов любым, удобным нам, способом.

Вступление
Прежде всего, нам нужно определиться, что мы будем сортировать, и как. Наш класс для поиска файлов имеет несколько методов find(...), которые возвращают список файлов (объект типа List) с объектами типа File. Таким образом, мы можем получить любую информацию о найденных файлах (имя, размер, размещение и т.д.).

Теперь решим, каким образом нам нужно отсортировать результаты поиска. Наиболее часто требуется сортировка по имени, типу, размеру и дате создания файла.

В этой статье мы напишем методы, необходимые для сортировки по имени файла (это одна из наиболее сложных сортировок). Итак, нам нужно, отсортировать все найденные файлы и папки в следующем порядке:

первыми идут файлы с минимальной глубиной вложения (т.е. те, которые находятся ближе к начальной папке поиска);
файлы, которые находятся внутри одной папки, должны быть отсортированы в алфавитном порядке (нужно обеспечить правильную обработку не латинских символов).

Результаты сортировки должны быть возвращены в виде списка (List) с объектами типа File, т.е. мы меняем только порядок следования элементов и ничего более.

Сортировка списка файлов на Java

Теперь, когда задача ясна, посмотрим, как мы можем её решить. В первую очередь, нам нужен какой-нибудь алгоритм сортировки. С этим проблем нет. На сегодняшний день, разработано множество таких алгоритмов. Парочку этих алгоритмов можно найти практически в любом учебнике по программированию. Так что, если хотите, берите книжку…, или можно воспользоваться стандартной библиотекой Java, конкретнее, методом sort(List list, Comparator c) класса Collections из пакета java.util.

Этот метод выполняет сортировку списка объектов, который передается ему в первом параметре (list). Тут у вас может возникнуть вполне закономерный вопрос: "А как именно он будет сортировать файлы". Ответ простой: "Так, как мы ему расскажем":-). Дело в том, что любой алгоритм сортировки принимает решения о порядке следования объектов на основании результатов их сравнения, т.е. при сортировке мы всегда должны иметь возможность получить результат сравнения двух любых объектов. Например, если бы мы сортировали список с объектами стандартного типа, например, int, то метод sort упорядочил бы их в порядке возрастания без дополнительных усилий с нашей стороны.

Но о том, как мы хотим отсортировать наш список, методу sort ничего не известно. Поэтому мы должны написать метод, который выполняет сравнение двух объектов из нашего списка. Этот метод (int compare(Object o1, Object o2)) определён в интерфейсе Comparator. Он должен возвращать «1», если первый аргумент (o1) больше второго (o2), «0» – если аргументы равны, и «-1» – если второй объект больше. Как вы, наверное, уже поняли, указатель на класс, который содержит наш метод сравнения (compare(...)) передаётся методу sort во втором параметре. Метод sort будет сортировать наши объекты в порядке возрастания, сравнивая их при помощи нашего метода compare(...). Изменяя метод compare(...) мы можем задать любой порядок сортировки.

Теперь посмотрим как будет выглядеть наш класс сортировки файлов (FileSorter)

package searchtools;

import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.io.File;

/**
 * Этот класс предназначен для сортировки списка файлов
 *
 * @author Стаценко Владимир
 * http://www.vova-prog.narod.ru
 */
public class FileSorter implements Comparator {

    Pattern p = null;
    Collator collator = null;

    /** Создает новые экземпляры FileSorter */
    public FileSorter() {
        .
        .
        .
    }

    /* Этот метод выполняет сравнение имен двух файлов.
     * Возвращает:
     *     1 если первый параметр (о1) больше второго (о2),
     *    -1 если первый параметр (о1) меньше второго (о2),
     *     0 если они равны.
     * Имя первого файла считается больше второго имени, если
     * первый файл находится ближе к корню дерева папок.
     * Если файлы находятся в одной папке, то больше то имя,
     * которое идет первым по алфавиту.
     */
    public int compare(Object o1, Object o2) {
        .
        .
        .
    }

    public List sort(List fileList) {
        ArrayList res = new ArrayList(fileList.size());
        res.addAll(fileList);
        Collections.sort(res, this);
        return res;
    }
}

Как видите, наш класс реализует интерфейс Comparator, и, соответственно, методу sort мы передаём указатель this.

Для того, чтобы наш класс заработал, нам осталось написать метод compare.

Тут все просто. В первую очередь, проверяем равенство объектов (если имена файлов одинаковы, то и файлы равны). Если файлы разные, определяем их глубину вложения. Как вы помните, сначала должны идти файлы с меньшей глубиной вложения. Наконец, если файлы находятся на одной глубине, сравниваем сами имена файлов.

Для определения глубины вложения файлов нам нужно узнать количество символов-разделителей в полном имени файла. Обратите внимание, определять символ-разделитель нужно с помощью переменной File.separator, т.к. он зависит от операционной системы.

Для подсчёта символов-разделителей можно использовать цикл, но есть и более удобный метод, основанный на использовании регулярных выражений (почитать о них вы можете в статье "Анализ данных с помощью регулярных выражений или быстрый способ проверки введенных данных" или в Java Tutorial).

Для поддержки различных кодировок очень удобно использовать классы Collator и Locale из пакета java.util. Метод compare класса Collator позволяет выполнить сортировку строк в соответствии с алфавитом языка, который установлен в настройках системы.

Теперь посмотрим на весь класс целиком.

/*
 * FileSorter.java
 *
*/

package searchtools;

import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.io.File;

/**
 * Этот класс предназначен для сортировки списка файлов
 *
 * @author Стаценко Владимир
 * http://www.vova-prog.narod.ru
 */
public class FileSorter implements Comparator {

    //класс для работы с регулярными выражениями
    Pattern p = null;
    //класс для работы со строками на разных языках
    Collator collator = null;

    /** Создает новые экземпляры FileSorter */
    public FileSorter() {
        //определяем системный символ разделитель и создаем
        //шаблон на его основе
        String separator = File.separator;
        if(separator.equals("\\")) {
            separator = "\\";
        }
        //создаем шаблон на основе символа-разделителя
        p = Pattern.compile(separator,
                Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);
        //получаем системные настройки (язык и страну)
        String country = System.getProperty("user.country");
        String language = System.getProperty("user.language");
        //создаем экземпляр класса для сравнения строк на
        //основе региональных настроек
        collator = Collator.getInstance(new Locale(country, language));
    }

    /**
     * Этот метод выполняет сравнение имен двух файлов.
     * Возвращает:
     *     1 если первый параметр (о1) больше второго (о2),
     *    -1 если первый параметр (о1) меньше второго (о2),
     *     0 если они равны.
     * Имя первого файла считается больше второго имени, если
     * первый файл находится ближе к корню дерева папок.
     * Если файлы находятся в одной папке, то больше то имя,
     * которое идет первым по алфавиту.
     * @param o1 объект типа File
     * @param o2 объект типа File
     * @return результат сравнения
     */
    public int compare(Object o1, Object o2) {
        //если объекты не равны null и имеют тип File
        if(o1 != null && o2 != null &&
                o1 instanceof File && o2 instanceof File) {
            //приводим к типу File
            File f1 = (File)o1;
            File f2 = (File)o2;
            //получаем полный путь к имени файла
            String fullPath1 = f1.getAbsolutePath();
            String fullPath2 = f2.getAbsolutePath();
            //проверяем равенство имен
            if(fullPath1.equals(fullPath2)) {
                //возвращаем 0, т.к. имена одинаковы
                return 0;
            }
            //определяем глубину размещения файла в дереве папок
            //для этого разбиваем полный путь к файлу на
            //лексемы, и определяем их количество
            String[] res1 = p.split(fullPath1);
            String[] res2 = p.split(fullPath2);
            if(res1.length > res2.length) {
                //возвращаем 1, если глубина вложения первого
                //файла больше глубины вложения второго
                return 1;
            }
            if(res1.length < res2.length) {
                //возвращаем "-1" в противном случае
                return -1;
            }
            if(res1.length == res2.length) {
                //если файлы находятся на одинаковой глубине,
                //сортируем их в соответствии с алфавитом
                return collator.compare(fullPath1, fullPath2);
            }
        }
        //здесь мы возвращаем 0, т.к. сравнение объектов
        //выполнить невозможно (т.е. считаем, что объекты
        //одинаковые, во всяком случае, сортировать их
        //нет смысла)
        return 0;
    }

    /**
     * Этот метод выполняет сортировку списка файлов
     * @param fileList не отсортированный список файлов
     * @return отсортированный список файлов
     */
    public List sort(List fileList) {
        //создаем список для результатов (такого же размера
        //как и исходный список)
        ArrayList res = new ArrayList(fileList.size());
        //копируем список
        res.addAll(fileList);
        //выполняем сортировку
        Collections.sort(res, this);
        //возвращаем результат
        return res;
    }
}

Как видите, значительная часть работы выполнена с помощью стандартных библиотек Java. Так что, можете быть уверены, время, потраченное на их изучение, быстро окупиться.

Если вы захотите изменить способ сортировки, например, сортировать файлы по их размеру, то просто измените метод compare.

Обеспечить поддержку нескольких видов сортировки немного сложнее. Я могу посоветовать использовать следующий метод.

Добавляем несколько констант и одну переменную.

private final int SORT_BY_NAME = 1; //сортировка по имени файла
private final int SORT_BY_SIZE = 2; //сортировка по размеру файла

private int sortType = 1; //в этой переменной сохраняем текущий тип сортировки

Во всех методах задаём тип сортировки:

public List sortByName(List fileList) {
    sortType = SORT_BY_NAME;
    ...
}
public List sortBySize(List fileList) {
    sortType = SORT_BY_SIZE;
    ...
}

А в методе compare добавляем оператор switch и, конечно, все нужные алгоритмы сравнения.

switch (sortType) {
    case SORT_BY_NAME:
    //сравнение объектов по их имени
    case SORT_BY_SIZE:
    //сравнение объектов по их размеру
}

Вот и все. Теперь мы можем не только искать файлы, но и выводить результаты поиска в удобном нам виде.

Создание приложения для поиска файлов на Java

Владимир — Sat, 18 Aug 2007 18:30:10 +0000

Сегодня любая операционная система имеет встроенные средства для поиска файлов. Во многих случаях что-то подобное хотелось бы использовать в своих программах. В этой статье я покажу, как создать небольшой Java класс, который можно будет использовать в любой программе для поиска файлов.

Создание класса для поиска файлов
Сегодня любая операционная система имеет встроенные средства для поиска файлов. Во многих случаях что-то подобное хотелось бы использовать в своих программах. В этой статье я покажу, как создать небольшой Java класс, который можно будет использовать в любой программе для поиска файлов.

В первую очередь, давайте определимся, что именно должен делать наш класс. Для большинства случаев, я думаю, будет достаточно таких возможностей:

поиск заданных файлов и папок в начальной папке и всех её вложенных папках;
общая статистика поиска (количество найденных файлов и папок, общий размер файлов);
использование регулярных выражений в качестве шаблонов для имен найденных файлов и папок (выборочный поиск);
поиск отдельно файлов, и отдельно папок.

Теперь посмотрим, какие стандартные библиотеки из JDK (java development kit) нам понадобятся. В состав пакета java.io входит класс File, предназначенный для работы с файлами и папками. Он имеет методы для определения содержимого папки. Так что, нам остаётся добавить просмотр вложенных папок и поддержку регулярных выражений.

Несколько слов о том, что такое регулярные выражения. Это текстовые строки, составленные по определённым правилам, которые можно использовать в качестве шаблонов. Библиотека Java содержит пакет java.util.regex, предназначенный для работы с регулярными выражениями. Подробнее почитать о правилах составления и возможностях регулярных выражений можно в статье: Анализ данных с помощью регулярных выражений или быстрый способ проверки введённых данных.

Таким образом, наш класс, назовём его FileFinder, должен иметь такой набор методов.

Для поиска файлов и папок:
public List findAll(String startPath) public List findAll(String startPath, String mask)
Для поиска только файлов:
public List findFiles(String startPath) public List findFiles(String startPath, String mask)
Для поиска только папок:
public List findDirectories(String startPath) public List findDirectories(String startPath, String mask)
Каждый найденный объект (файл или папка) включается в список результатов только в том случае, если он соответствует регулярному выражению, заданному в параметре mask. Все методы возвращают результат в виде списка объектов типа File.

С помощью методов:
public long getDirectorySize() public long getFilesNumber() public long getDirectoriesNumber()
определяем количество найденных файлов и папок, и размер файлов.

Теперь, рассмотрим самую интересную часть. Поиск файлов. Он выполняется с помощью двух методов. Первый,
private List find(String startPath, String mask, int objectType)
выполняет начальную подготовку к поиску: сброс счётчиков, проверку допустимости параметров, компиляцию регулярного выражения и т.п.. Второй метод,
private void search(File topDirectory, List res, int objectType)
вызывается только из метода find(...), он и выполняет поиск. В качестве параметров, методу search(...) передаются: имя папки, указатель на список для хранения найденных объектов, и тип нужного объекта (файлы, папки, всё подряд). С помощью метода listFiles() класса File определяем список файлов и папок в текущей папке (параметр topDirectory), а затем, для каждой найденной папки снова вызываем метод search(...), но в параметре topDirectory передаём найденную папку. Такой способ вызова методов называется рекурсией. Т.е. метод search(...) будет вызывать сам себя до тех пор, пока не пройдёт все вложенные папки. Каждый найденный объект (папка или файл) проверяется на соответствие регулярному выражению (если оно задано) с помощью метода accept(), и, если проверка прошла успешно, добавляется в список результатов.

Теперь посмотрим на весь класс целиком.

package searchtools;

import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Этот класс предназначен для поиска файлов
 *
 * @author Стаценко Владимир
 * http://www.vova-prog.narod.ru
 */
public class FileFinder {

    //классы для работы с регулярными выражениями
    private Pattern p = null;
    private Matcher m = null;

    //общий размер найденных файлов
    private long totalLength = 0;
    //общее количество найденных файлов
    private long filesNumber = 0;
    //общее количество просмотренных директорий
    private long directoriesNumber = 0;

    //константы для определения объектов, которые нужно найти
    private final int FILES = 0;
    private final int DIRECTORIES = 1;
    private final int ALL = 2;

    /** Создает новые экземпляры FileFinder */
    public FileFinder() {
    }

    /**
     * Этот метод выполняет поиск всех объектов (файлов и директорий),
     * начиная с заданной директории (startPath)
     * @param startPath Начальная директория поиска
     * @return Список (List) найденных объектов
     * @throws java.lang.Exception если возникли ошибки в процессе поиска
     */
    public List findAll(String startPath) throws Exception {
        return find(startPath, "", ALL);
    }

    /**
     * Этот метод выполняет поиск объектов (файлов и директорий),
     * которые соответствуют заданному регулярному выражению (mask),
     * начиная с заданной директории (startPath)
     * @param startPath Начальная директория поиска
     * @param mask регулярное выражение, которому должны соответствовать
     * имена найденный объектов
     * @throws java.lang.Exception если возникли ошибки в процессе поиска
     * @return Список (List) найденных объектов
     */
    public List findAll(String startPath, String mask)
            throws Exception {
        return find(startPath, mask, ALL);
    }

    /**
     * Этот метод выполняет поиск всех файлов,
     * начиная с заданной директории (startPath)
     * @param startPath Начальная директория поиска
     * @return Список (List) найденных объектов
     * @throws java.lang.Exception если возникли ошибки в процессе поиска
     */
    public List findFiles(String startPath)
            throws Exception {
        return find(startPath, "", FILES);
    }

    /**
     * Этот метод выполняет поиск файлов,
     * которые соответствуют заданному регулярному выражению (mask),
     * начиная с заданной директории (startPath)
     * @param startPath Начальная директория поиска
     * @param mask регулярное выражение, которому должны соответствовать
     * имена найденный объектов
     * @throws java.lang.Exception если возникли ошибки в процессе поиска
     * @return Список (List) найденных объектов
     */
    public List findFiles(String startPath, String mask)
            throws Exception {
        return find(startPath, mask, FILES);
    }

    /**
     * Этот метод выполняет поиск всех директорий (папок),
     * начиная с заданной директории (startPath)
     * @param startPath Начальная директория поиска
     * @return Список (List) найденных объектов
     * @throws java.lang.Exception если возникли ошибки в процессе поиска
     */
    public List findDirectories(String startPath)
            throws Exception {
        return find(startPath, "", DIRECTORIES);
    }

    /**
     * Этот метод выполняет поиск директорий (папок),
     * которые соответствуют заданному регулярному выражению (mask),
     * начиная с заданной директории (startPath)
     * @param startPath Начальная директория поиска
     * @param mask регулярное выражение, которому должны соответствовать
     * имена найденный объектов
     * @throws java.lang.Exception если возникли ошибки в процессе поиска
     * @return Список (List) найденных объектов
     */
    public List findDirectories(String startPath, String mask)
            throws Exception {
        return find(startPath, mask, DIRECTORIES);
    }

    /**
     * Возвращает суммарный размер найденных файлов
     * @return размер найденных файлов (байт)
     */
    public long getDirectorySize() {
        return totalLength;
    }

    /**
     * Возвращает общее количество найденных файлов
     * @return количество найденных файлов
     */
    public long getFilesNumber() {
        return filesNumber;
    }

    /**
     * Возвращает общее количество найденных директорий (папок)
     * @return количество найденных директорий (папок)
     */
    public long getDirectoriesNumber() {
        return directoriesNumber;
    }

    /*
    Проверяет, соответствует ли имя файла заданному
    регулярному выражению. Возвращает true, если найденный
    объект соответствует регулярному выражению, false - в
    противном случае.
    */
    private boolean accept(String name) {
        //если регулярное выражение не задано...
        if(p == null) {
            //...значит объект подходит
            return true;
        }
        //создаем Matcher
        m = p.matcher(name);
        //выполняем проверку
        if(m.matches()) {
            return true;
        }
        else {
            return false;
        }
    }

    /*
    Этот метод выполняет начальные установки поиска.
    Затем вызывает метод search для выполнения поиска.
    */
    private List find(String startPath, String mask, int objectType)
            throws Exception {
        //проверка параметров
        if(startPath == null || mask == null) {
            throw new Exception("Ошибка: не заданы параметры поиска");
        }
        File topDirectory = new File(startPath);
        if(!topDirectory.exists()) {
            throw new Exception("Ошибка: указанный путь не существует");
        }
        //если задано регулярное выражение, создаем Pattern
        if(!mask.equals("")) {
            p = Pattern.compile(mask,
                    Pattern.CASE_INSENSITIVE | Pattern.UNIcomment_CASE);
        }
        //обнуляем все счетчики
        filesNumber = 0;
        directoriesNumber = 0;
        totalLength = 0;
        //создаем список результатов
        ArrayList res = new ArrayList(100);

        //выполняем поиск
        search(topDirectory, res, objectType);

        //присваиваем null шаблону, т.к. при следующем вызове find...
        //регулярное выражение может быть не задано
        p = null;
        //возвращаем результат
        return res;
    }

    /*
    Этот метод выполняет поиск объектов заданного типа.
    Если, в процессе поиска, встречает вложенную директорию
    (папку), то рекурсивно вызывает сам себя.
    Результаты поиска сохраняются в параметре res.
    Текущая директория - topDirectory.
    Тип объекта (файл или директория) - objectType.
    */
    private void search(File topDirectory, List res, int objectType) {
        //получаем список всех объектов в текущей директории
        File[] list = topDirectory.listFiles();
        //просматриваем все объекты по-очереди
        for(int i = 0; i < list.length; i++) {
            //если это директория (папка)...
            if(list[i].isDirectory()) {
                //...выполняем проверку на соответствие типу объекта
                // и регулярному выражению...
                if(objectType != FILES && accept(list[i].getName())) {
                    //...добавляем текущий объект в список результатов,
                    //и обновляем значения счетчиков
                    directoriesNumber++;
                    res.add(list[i]);
                }
                //выполняем поиск во вложенных директориях
                search(list[i], res, objectType);
            }
            //если это файл
            else {
                //...выполняем проверку на соответствие типу объекта
                // и регулярному выражению...
                if(objectType != DIRECTORIES && accept(list[i].getName())) {
                    //...добавляем текущий объект в список результатов,
                    //и обновляем значения счетчиков
                    filesNumber++;
                    totalLength += list[i].length();
                    res.add(list[i]);
                }
            }
        }
    }
}

Как видите, ничего сложного. Большая часть – это комментарии.

Средства разработки Java приложений: необходимые и просто полезные программы

Владимир — Sat, 18 Aug 2007 18:04:37 +0000

Какой бы язык программирования вы не начали изучать, вам неизбежно придётся столкнуться с проблемой выбора нужных для разработки программ.
Программирование на Java не исключение. Скорее наоборот. Количество различных сред разработки исчисляется десятками.
В этой статье я хочу рассказать о минимально необходимом комплекте инструментов для разработки на Java, и о некоторых программах, которые значительно облегчают жизнь программиста.

Необходимые программы
Одно из значительных, на мой взгляд, преимуществ Java перед другими языками программирования, это наличие бесплатных интегрированных сред разработки (IDE), которые по возможностям практически не уступают их коммерческим аналогам.

Я не собираюсь приводить подробный анализ каждой программы. Это не реально сделать в одной статье (даже очень большой:-)). Я просто расскажу о доступных и бесплатных инструментах, которыми сам пользуюсь.

Итак, начнём с необходимых программ.

Разработчиком языка Java является Sun Microsystems. Она же и предоставляет необходимое программное обеспечение (http://java.sun.com/).

Для запуска программ нам понадобится среда выполнения Java – Java Runtime Environment (JRE).

Т.к. одним запуском программ мы не ограничиваемся, то следующим у нас по списку идет комплект разработки программного обеспечения – JDK (Java Development Kit). Он содержит компилятор, стандартные библиотеки и т.п.

Тут необходимы некоторые пояснения. Существует три Java платформы:

1. Java 2 Standard Edition (J2SE)
2. Java 2 Enterprise Edition (J2EE)
3. Java 2 Micro Edition (J2ME)

Каждая из этих платформ предназначена для разработки своего типа программ.

Первая (J2SE) позволяет разрабатывать обычные (desktop) приложения и апплеты (по-сути такие же приложения, только с возможностью внедрения в html-страницу).

Вторая (J2EE) предназначена для разработки серверных приложений (сервлетов, jsp-страниц, компонентов JavaBeans). По сути, J2EE это J2SE плюс Java System Application Server (сервер приложений) и дополнительные библиотеки.

Третья (J2ME) – это платформа для мобильных устройств. Она не входит ни в одну из предыдущих, хотя похожа на J2SE. Дело в том, что мобильные устройства (телефоны, КПК и т.д.) обладают значительно меньшими ресурсами, по сравнению с обычными компьютерами и ноутбуками. И это касается не только памяти и процессора, но и размеров экрана и клавиатуры. Поэтому в J2ME большинство библиотек имеют ограниченный набор возможностей, по сравнению с J2SE, или вообще совершенно другие.

Завершает список минимально необходимых программ текстовый редактор. Очень желательно с подсветкой синтаксиса.

Выбор тут очень большой. От простейших, вроде Блокнота, до достаточно "продвинутых", например, syn Text Editor.

Советую обратить внимание на Notepad++, syn Text Editor, PSPad. Все они обеспечивают подсветку синтаксиса, работу с несколькими файлами (в табах), подсветку скобок ({}) и т.п.

Наличие такого редактора полезно, даже если вы используете IDE. Потому что очень часто нужно просто посмотреть какой-нибудь файл, а в IDE открыть другой проект, и открывать в ней дополнительные файлы не очень удобно, возникает путаница.

Таким образом, мы имеем минимальный комплект для разработки программ на Java:

JRE – среда выполнения;
JDK для соответствующей платформы (J2SE, J2EE, J2ME) – компилятор и библиотеки;
текстовый редактор.

Минимальный комплект даёт возможность писать программы, но не более того. Каждая операция (компиляция, запуск, создание jar-файла) потребует введения длинных команд в консоли. Ясно, что это дело быстро надоест.

Тут очень пригодиться программа под названием Apache Ant. По сути, это аналог утилиты make, только кроссплатформенный и ориентированный на использование с Java. С его помощью можно автоматизировать практически любую последовательность операций. Например, вы можете выполнить компиляцию проекта, протестировать его и упаковать в jar-архив с помощью всего одной команды. Для этого нужно только создать build-файл с соответствующими задачами. Подробнее о том, как это сделать, можно почитать в статье: Настройка и использование Apache Ant.
В общем, Ant приобрёл очень широкое распространение, и используется как составляющая часть многих Java IDE.

Теперь перейдём к более "продвинутым" средствам разработки, т.е. интегрированным средам разработки (IDE).

Как я уже говорил, выбор довольно большой. Но я бы хотел выделить две: NetBeans и Eclipse. Почему именно эти? Все просто. Во-первых, они полностью бесплатные. Во-вторых, они поддерживают разработку на всех трёх платформах (J2SE, J2EE, J2ME).

Анализ данных с помощью регулярных выражений или быстрый способ проверки введенных данных

Владимир — Sat, 18 Aug 2007 17:21:22 +0000

Все, кто хоть немного занимается программированием, сталкивались с проблемой правильности ввода данных. Основная сложность заключается в том, что большинство людей не любят читать справку к программе, не любят по несколько раз проверять введённые данные, зато очень любят быстро нажимать на все кнопки подряд, и громко жаловаться на малейшие ошибки в программе:-).

Регулярные выражения. Зачем они нужны?
Кроме того, существуют объективные причины возникновения ошибок. Например, усталость или некачественно составленная документация.

Все это приводит к тому, что программист вынужден тщательно проверять вводимые данные, и сообщать обо всех ошибках пользователю, объясняя при этом как эту ошибку исправить.

В большинстве случаев данные от пользователя поступают в виде текстовых строк. Т.е. нам нужно преобразовать данные к определённому типу.
И вот здесь все зависит от того, какие именно данные мы хотим получить.
Если нам нужен просто какой-нибудь текст (например, имя пользователя), то проверка достаточно простая:

if(name == null || name.equals("")) {
//сообщение об ошибке
}

Мы просто убеждаемся, что что-то введено.
Проверить правильность ввода чисел тоже несложно. Можно воспользоваться методами parse… классов Double, Integer и т.п.

Например,

try {
    int v = Integer. parseInt(inputString);
}
catch(NumberFormatException err) {
// сообщение об ошибке
}

Но, есть данные, для которых используется специальная форма записи. Например, адреса eMail, телефонные номера и т.п.

Проверку таких данных выполнить сложнее. Нужно проверять наличие обязательных элементов (например, символ @ в адресе eMail), их взаимное расположение и т.д.
Кроме того, могут возникнуть дополнительные задачи. Например, выделение кода города из телефонного номера.
Конечно, для выполнения таких проверок можно написать специальную функцию, содержащую один или несколько циклов, в которых будет выполняться проверка соответствия строки всем требованиям. Но в этом случае, зачастую, получается, что объем кода, выполняющего эти проверки, составляет, чуть ли не половину всей программу (если не больше).

К счастью, существует ряд методов, позволяющих существенно упростить задачу.
Об одном из них я и хочу рассказать. Этот метод заключается в использовании регулярных выражений (regular expressions).
Никогда о них не слышали? Не страшно. Я уверен, что вы постоянно ими пользуетесь. Например, если вам нужно найти все файлы с расширением mp3, то в программе поиска вы пишите "*.mp3". Это и есть регулярное выражение. В данном случае программа поиска выдаст вам список файлов, у которых имя состоит из любого количества любых символов, после имени идет символ ".", а за ним – "*mp3". Если вы напишите "A*.mp3", то получите список файлов, которые начинаются на букву "A", и имеют расширение "mp3".

Вообще, регулярное выражение представляет собой шаблон, с которым можно сравнивать текстовые строки. В приведённом примере, программа поиска сравнивает все имена файлов с заданным шаблоном, и показывает только те, которые с ним совпали.

Средства Java для работы с регулярными выражениями

В стандартную библиотеку Java входит пакет, специально предназначенный для работы с регулярными выражениями – java.util.regex.
Эта библиотека может быть использована для выполнения таких задач:

поиск данных;
проверка данных;
выборочное изменение данных;
выделение фрагментов данных;
и др..

Получить подробную информацию о библиотеке можно из официальной справки к JavaSDK, размещённой на сайте java.sun.com. Здесь же можно почитать The Java Tutorial (учебное пособие по Java), в котором регулярным выражениям посвящён отдельный урок.

В этой статье я хочу показать примеры использования регулярных выражений для проверки правильности ввода данных, и извлечения фрагментов этих данных.
Основную работу выполняют два класса: Pattern и Matcher.
Pattern – представляет собой сам шаблон, т.е. наше регулярное выражение.
Matcher – это объект, который выполняет сравнение заданной строки с шаблоном.
Для того чтобы создать объект типа Pattern нужно воспользоваться его статическим методом
compile(< регулярное выражение >) или
compile(< регулярное выражение >, <параметры>).
Создать Matcher можно с помощью объекта Pattern.

Например, так:

Pattern p = Pattern.compile("^\\s+",
    Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(inputString);

После этого можно сравнивать шаблон со строкой, выполнять поиск нужных фрагментов и т.д.
Но, прежде всего, давайте разберёмся, как составлять регулярные выражения.

В простейшем случае регулярное выражение представляет собой просто текст, например, "стол". Такое выражение можно использовать для поиска слова "стол" в строке, для замены этого слова на какое-нибудь другое и т.д..

Для создания более сложных выражений используются специальные символы (метасимволы). К ним относятся: ([{\^$|)?*+.. Эти символы имеют специальное значение, которое зависит от их положения в выражении.

Но, что будет, если мы захотим использовать эти символы в выражении в их обычном значении? Для этого нужно перед этим символом поставить \.

Внимание: если регулярное выражение записано в программе, а не читается из файла или формы, то необходимо использовать два символа \ подряд (\\). Вы, конечно, помните, что при обработке строк Java считает символ \ служебным (начало эскейп-последовательности), а для того, чтобы получить просто \ нужно ввести \\.

Теперь посмотрим, как можно использовать специальные символы при составлении выражений. Наверное, наиболее распространённый символ – это ".". Он означает – любой символ. Если поставить справа от символа знак "+", то это будет означать, что предыдущий символ может встречаться несколько раз. Поясню сказанное на простых примерах:
выражение ".+" будет соответствовать любому тексту (один или более любых символов);
"A.+" – любое выражение, которое начинается на букву "А".
Если мы хотим найти текст с известным расположением в строке, то можно воспользоваться символами:
^ - начало строки
$ - конец строки

С помощью квадратных скобок ([]) можно задать класс символов. Класс символов задаёт некоторый набор символов, который можно использовать в выражениях. Например, выражение "[кп]от" соответствует словам "кот" и "пот".
Вот ещё несколько примеров использования классов символов.

`[^abc]`	любые символы кроме abc (в данном случае символ ^ используется как отрицание)
`[a-d[m-p]]`	любые символы от a до d и от m до p (по алфавиту)
`[a-z&&[^bc]]`	любые символы от a до z кроме b и c

Кроме этого существуют, так называемые предопределённые классы. Например,

`\d`	означает любую цифру
`\D`	любые символы кроме цифр
\s	пробельные символы (`[ \t\n\x0B\f\r]`)
`\S`	любые символы кроме пробельных
`\w`	любые текстовые символы `[a-zA-Z_0-9]` (как вы заметили сюда символы русского алфавита не входят, как их включить, я покажу позже)
`\W`	любые не текстовые символы

Тщательная перетасовка колоды карт. Пример Java приложения.

Владимир — Fri, 17 Aug 2007 13:14:47 +0000

В данной статье я бы хотел показать один из вариантов алгоритма, выполняющего перетасовку колоды игральных карт, и, безусловно, обсудить его достоинства и недостатки.

Если вы захотите написать программу для игры в карты, то неизбежно столкнетесь с необходимостью перетасовки колоды карт. Обычно, эта операция выполняется перед каждой сдачей карт, то есть, возможно, десятки раз за игру (в зависимости от правил конкретной игры). Поэтому качество выполнения данной операции может существенно сказаться на результатах игры.

На первый взгляд, в решении этой задачи нет ничего сложного. Нужно просто поменять местами карты в колоде так, чтобы они располагались случайным образом. Но что означает "случайным образом"? Ответ простой: "Во взаимном расположении карт не должно быть никаких закономерностей". Но ведь компьютер выполняет только то, что написано в программе. Команды из серии: "Возьми то, не знаю что", тут не проходят. Поэтому в первую очередь нам нужен источник случайных чисел.

И вот тут возникает проблема. На сегодняшний день не существует источника по-настоящему случайных чисел. Но зато есть огромное количество алгоритмов, которые позволяют получать, так называемые, псевдослучайные числа. Практически каждый язык программирования имеет встроенные функции для генерирования псевдослучайных последовательностей чисел. Разница между случайными и псевдослучайными числами в том, что последние получены с использованием какого-то алгоритма. А это означает наличие некоторой закономерности в появлении таких чисел.

Я не буду анализировать особенности этих алгоритмов, это тема не статьи, а книги (скорее нескольких). Те, кому интересно, могут посмотреть литературу по вычислительной математике или теории чисел.

В этой статье я расскажу о возможностях, которые нам предоставляет стандартная библиотека языка Java. Есть два варианта. Первый – использовать метод random() класса java.lang.Math.. Второй – воспользоваться одним из методов класса java.util.Random.

Мы будем использовать второй вариант, т.к. он обеспечивает более широкую функциональность.

В первую очередь, я хочу показать, что этот класс генерирует псевдослучайные числа. Напишем простенькую программку:

import java.util.Random;public class Main {
public Main() {
    }
public static void main(String[] args) {
        //создаем новый генератор псевдослучайных чисел, и задаем
        //начальное значение для алгоритма генерации чисел
        Random generator = new Random(20);
        //выводим десять случайных чисел
        for(int i = 0; i < 10; i++) {
            if(i == 9) {
                System.out.println(generator.nextInt(100));
            }
            else {
                System.out.print(generator.nextInt(100) + "; ");
            }
        }
    }
}

Тут все предельно просто. Программа генерирует 10 случайных чисел, и выводит их в одну строку. Если мы запустим программу 3 раза подряд, то получим три строки с числами:
53; 36; 1; 61; 5; 95; 33; 55; 93; 88 53; 36; 1; 61; 5; 95; 33; 55; 93; 88 53; 36; 1; 61; 5; 95; 33; 55; 93; 88
Как видите, все строки одинаковые. Это происходит из-за того, что аргументом в конструкторе класса Random у нас является одно и то же число (20). Кстати, если использовать конструктор без аргументов, то начальное значение будет выбрано по специальному алгоритму, и генерируемые числа будут разными.

Но я не зря использовал именно этот конструктор. Дело в том, что в качестве начального значения для генератора случайных чисел можно использовать текущее значение системного времени. Действительно, нельзя точно предугадать в какой момент времени пользователь запустит программу, миллисекундой раньше, миллисекундой позже…

Создать генератор случайных чисел, с системным временем в качестве базового числа, можно так:

Random generator = new Random(new Date().getTime());

Или, если у вас уже есть объект типа Random:

generator.setSeed(new Date().getTime());

Итак, с созданием случайных чисел разобрались. Переходим непосредственно к алгоритму перетасовки карт.
Прежде всего, просмотрите его исходный код, а затем я объясню, как это все работает.

public static void reshuffle(int[] pack) {
    if(pack != null) {
        int length = pack.length;
        //создаем генератор случайных чисел, в качестве начального
        //значения передаем системное время
        Random generator = new Random(new Date().getTime());
        //тосуем колоду карт
        //перебираем все карты колоды
        for(int i = 0; i < length; i++) {
            //генерируем случайное число, в диапазоне от нуля до
            //конца колоды
            int newPos = generator.nextInt(length);
            //меняем местами текущую карту с картой, которая находится
            //в pack[newPos]
            int curCard = pack[i];
            pack[i] = pack[newPos];
            pack[newPos] = curCard;
            //для увеличения эффекта "случайности" возникновения чисел,
            //в течении перетасовки колоды, четыре раза устанавливаем
            //новое начальное значение генератора случайных чисел
            if(i%(length/4) == 0) {
                //генерируем случайный интервал времени (мс)
                int pause = generator.nextInt(20);
                try {
                    //останавливаем работу программы на полученный
                    //интервал времени (максимально возможная задержка
                    //восемдесят миллисекунд)
                    Thread.currentThread().sleep(pause);
                }
                catch (InterruptedException ex) {}
                //уставливаем новое начальное значение генератора
                generator.setSeed(new Date().getTime());
            }
        }
    }
}

За основу я взял давно известный алгоритм, но для увеличения степени “случайности” возникновения чисел, ввел несколько изменений.

Допустим, у нас есть колода из 36 карт. Для её хранения мы используем массив из 36 элементов, каждый из которых может принимать значения от 0 до 35.

Перетасовка выполняется следующим образом. Мы последовательно перебираем все ячейки массива с картами. Для каждой ячейки мы генерируем случайное число (newPos) в диапазоне от 0 до 35. Это число является новым положением карты в массиве. Т.е. мы меняем местами текущую карту с картой, которая лежит в ячейке с индексом newPos.

Теперь обратите внимание на строки начиная с if(i%(length/4) == 0) {. Этот блок кода будет выполняться четыре раза в течение работы метода. Принцип работы следующий. В первую очередь мы получаем случайное число в диапазоне от 0 до 20. Почему выбран именно этот диапазон, я объясню чуть позже. Это число задает время, на которое программа приостанавливает свою работу.

Остановка программы выполняем с помощью метода sleep(). После этого, мы опять устанавливаем текущее время в качестве нового базового значения для генератора случайных чисел.

Теперь разберемся, что все это нам дает. В первую очередь увеличивается время выполнения перетасовки. Это, конечно, не очень хорошо, но давайте подумаем. Максимально возможная задержка составляет 80 мс. Данный алгоритм предназначен для использования в карточных играх, в которых, при перетасовке карт, игроку обычно показывают какую-нибудь анимацию (это увеличивает реалистичность игры). Длительность такой анимации обычно около секунды или больше (игрок должен хоть что-то рассмотреть:-)). Т.е., за время этой анимации, можно будет раз десять перетасовать колоду.

А теперь посмотрим на сильные стороны этого алгоритма. Мы четыре раза устанавливаем новое базовое число. Предсказать значение этого числа практически невозможно, и не только потому, что длительность паузы мы выбираем случайным образом. Любая современная операционная система вносит дополнительный эффект случайности в работу алгоритма. Дело в том, что в системе выполняется одновременно несколько десятков процессов (программ). Но один процессор (не многоядерный) может выполнять одновременно только одну программу. Поэтому для создания эффекта многозадачности используется специальная программа – планировщик, которая переключает процессы. Сначала выполняется несколько команд из одной программы, потом – несколько из другой, и так далее. Порядок переключения программ зависит от многих причин. Это и приоритеты процессов, и тактовая частота процессора, и версия операционной системы, и многое другое.

Таким образом, существует высокая вероятность того, что выполнение нашего метода перетасовки будет прервано планировщиком (и не один раз). Системное время, естественно, не зависит от порядка работы нашей программы, и значения, которые возвращает метод getTime() предсказать практически невозможно. А именно этого мы и добиваемся.

Для тестирования работы алгоритма я написал небольшую программу. В неё входят 3 файла с исходными кодами. Reshuffler.java – имеет один статический метод, который и выполняет перетасовку карт. CardsPack.java – этот файл, содержит класс, который используется для создания колоды карт. Он содержит два метода: getPackOfCards() – возвращает массив с номерами карт;
toString() – возвращает строку с названиями карт в колоде.
Оба эти метода находятся в пакете cards.tools.
Main.java – содержит класс с функцией main, которая выполняет следующие операции:

создает новую колоду;
выводит её содержимое;
перетасовывает колоду;
и опять выводит её содержимое.

Теперь посмотрим результаты работы программы:

Начальное расположение карт в колоде

Расположение карт после сортировки

шестерка пик
семерка пик
восьмерка пик
девятка пик
десятка пик
валет пик
дама пик
король пик
туз пик
шестерка треф
семерка треф
восьмерка треф
девятка треф
десятка треф
валет треф
дама треф
король треф
туз треф
шестерка бубен
семерка бубен
восьмерка бубен
девятка бубен
десятка бубен
валет бубен
дама бубен
король бубен
туз бубен
шестерка червей
семерка червей
восьмерка червей
девятка червей
десятка червей
валет червей
дама червей
король червей
туз червей

король пик
десятка червей
король червей
восьмерка червей
девятка треф
валет червей
восьмерка треф
десятка пик
шестерка треф
семерка треф
шестерка бубен
король бубен
туз треф
валет пик
туз бубен
девятка пик
король треф
валет бубен
восьмерка пик
дама пик
дама треф
девятка червей
семерка бубен
туз червей
десятка треф
семерка червей
шестерка червей
десятка бубен
дама бубен
восьмерка бубен
девятка бубен
туз пик
шестерка пик
семерка пик
дама червей
валет треф

Как видите, у нас все получилось.

Скачать исходный код проекта: cards_reshuffler_src.zip (2,6 кБ).

Скачать программу:cards_reshuffler_prog.zip (2,3 кБ).

Желаю успехов.

Постовой

центр озонотерапии
клиническая психотерапия

Настройка и использование Apache Ant для разработки Java приложений

Владимир — Fri, 17 Aug 2007 11:48:48 +0000

Практически все, кто когда-нибудь занимался программированием на Java, слышали о программе под названием Apache Ant. Её используют большинство современных сред разработки, такие как Eclipse, NetBeans и многие другие. Так чем же объясняется такая популярность Ant?

Вступление, или несколько слов о том, зачем это надо

Давайте разбираться по порядку. Ant – это инструмент для работы с проектами, в самом широком смысле. С его помощью можно выполнить компиляцию, отладку и тестирование проекта, создавать новые и удалять существующие файлы и папки, создавать архивы с исходными кодами, и многое другое. Перечень функций, которые поддерживает Ant, занимает несколько страниц, кроме того, вы можете создавать свои собственные функции.

Тут возникает вопрос: "Ну и что, все эти операции можно выполнить и без Ant". Да, можно, но Ant даёт возможность это сделать с помощью всего одной команды. Это не только ускоряет работу, но и страхует от ошибок. При выполнении длинной цепочки действий всегда можно что-нибудь забыть.

Естественно, все эти операции Ant выполняет с помощью дополнительных средств, например, для компиляции проекта у вас должен быть установлен Java SDK (software development kit). Сам по себе, Ant выполняет чтение и анализ специального файла (обычно он называется build.xml), который содержит команды для работы с проектом. Этот файл вы можете создать сами, либо с помощью вашей IDE в ходе разработки проекта.

Как создать такой файл мы рассмотрим чуть позже, а пока разберёмся, какие преимущества нам даёт использование Ant.
Рассмотрим простой пример. Допустим, у нас есть проект, состоящий из одного файла (hello.java) с, наверное, самой популярной в мире программой "Hello, World!".

Наши задачи:
1) скомпилировать программу;
2) запустить её (для проверки работоспособности);
3) создать jar-файл (файл manifest.mf у нас есть);
4) создать архив с исходниками (например, для размещения в Internet).

В классическом варианте (без использования IDE) для первых трех пунктов вы должны выполнить примерно такой набор команд:

javac hello.java java hello jar cmf hello.jar manifest.mf hello.class

Четвёртый пункт выполняется с помощью вашего любимого архиватора.

Ясно, что писать эти команды после каждого изменения в проекте быстро надоест, особенно, если ваш проект состоит из десятков или сотен файлов, которые расположены в разных папках.
Конечно, самый простой способ решения этой проблемы – использовать какую-нибудь IDE. В этом случае для выполнения первых трех пунктов будет достаточно нажать одну кнопку.
Но вот четвёртый пункт вам, скорее всего, придётся выполнять вручную. А это потенциальный источник ошибок. Можно легко забыть добавить в архив папку с ресурсами к программе, или с тестами, или ещё с чем-нибудь.
Кроме того, у вас могут быть чужие исходники, например, примеры к документации, которые нужно просто запустить, а не заниматься их импортированием в IDE. Или вы хотите передать кому-нибудь свою программу в виде исходных кодов, а этот человек пользуется другой IDE.

Во всех этих случаях использование Ant значительно облегчит вам жизнь.

Пример Java приложения. CNC 1.1 – калькулятор комплексных чисел

Владимир — Fri, 17 Aug 2007 08:06:28 +0000

CNC 1.1 (Complex Number Calculator) – калькулятор комплексных чисел
Эта программа представляет собой обычный калькулятор с поддержкой комплексных чисел. Использовать её очень просто. Вы вводите математическое выражение, нажимаете кнопку "=", и получаете ответ.

Пользоваться апплетом очень просто. Вводите выражение, которое нужно вычислить в верхнее окно, например, "(1,3 + 4,5)*(3 - 2i) - 4i" и нажимаете кнопку " = ". Справа появляется результат "17,4-15,6i". В нижнем окне ведётся протокол всех вычислений. Тут же выводятся сообщения об ошибках. Новая запись добавляется каждый раз когда вы нажимаете кнопку " = ".

ВНИМАНИЕ! Разделитель целой и дробной части (точка или запятая) зависит от настроек вашей операционной системы. Например, в MS Windows эти настройки можно изменить в окне "Языки и региональные стандарты" (Пуск/Настройка/ Панель управления/Языки и региональные стандарты). При этом если, например, вы введёте "2.2", а десятичный разделитель у вас – запятая, то программа просто отбросит все, что идёт после точки, т.е. такое число будет считаться равным "2".

Вы можете использовать следующие операции:

"+" – сложение
"-" – вычитание
"*" – умножение
"/" – деление

Кроме этого можно использовать круглые скобки – "(", ")".

Например:

(2 + 3i) - 5 + 11,6 89,7 - (5-2*3)/(2,4 + 3i) (3i - (2 * 5 + 4i/(2,35 + 4,75)))

Инструкции по использованию апплета и исходники

Вы можете использовать эту программу и изменять её исходный код без каких-либо ограничений.

Существует два варианта CNC: Java-апплет и Java-программа. Как вы понимаете, работают они одинаково. Но их внешний вид может различаться. Дело в том, что программа определяет какая операционная система у вас установлена, и использует соответствующий внешний вид (Look And Feel). Апплет не может определить, на какой платформе он запущен (из-за ограничений, связанных с безопасностью), поэтому все компоненты апплета имеют обычный вид (CrossPlatformLookAndFeel).

Для того, чтобы запустить программу или апплет вам нужно установить J2SE JRE (Java 2 Standart Edition Java Runtime Environment). (У меня установлена версия 1.4.2_03). А для работы с исходными кодами вам также понадобиться SDK (Software Development Kit).
Скачать их можно с сайта Sun Microsystems.

Программа упакована в jar-архив, поэтому для её запуска вам нужно только сделать двойной щелчок по иконке.

Апплет тоже упакован в jar-архив. Встроить его в html-страницу можно так:

Скачать:

Исходный код (calc_src.zip – 12,4 кБ). Файл "mainFrame.java" – содержит функцию main программы (для апплета не нужен). Файл "CNC_1_0_applet.java" – содержит метод init апплета (для программы не нужен). Все остальные файлы общие.

Апплет (CNC_1_1_applet.zip – 12,6 кБ)

Программу (CNC_1_1.jar – 12,6 кБ)

Java апплет. Стрелочные часы.

Владимир — Fri, 17 Aug 2007 07:37:14 +0000

Этот пример демонстрирует базовые возможности библиотеки Graphics2D, которая используется для работы с двумерными изображениями. Здесь подробно описаны создание и работа апплета, представляющего собой стрелочные часы. На этом примере мы рассмотрим использование многих возможностей библиотеки: создание сложных геометрических форм, управление сглаживанием и прозрачностью, изменение рисунка в реальном времени, двойную буферизацию и др.

Апплет создаёт обычные стрелочные часы. Если заметите, что они показывают не то время, которое вы хотели бы видеть, просто измените время системных часов на вашем компьютере, и, максимум через секунду все будет нормально.

Посмотреть пример работающего апплета можно здесь.

Если апплет у вас не запустился, то, возможно, вам нужно установить Java Plug-in. Его установка происходит автоматически, когда вы устанавливаете J2SE JRE (java 2 standart edition java runtime environment) или SDK (software development kit). Скачать их можно с сайта Sun Microsystems.
Апплет тестировался с версиями 1.4.2_03 и 1.5.0_06.

Апплет создан с помощью NetBeans IDE 3.6

Подробно работа апплета описана в комментариях к исходным кодам. Здесь я хочу описать только на основные принципы работы апплета и особенности его использования.

В первую очередь рассмотрим, как встроить апплет в web-страницу.

Первая строка стандартная. В ней задаются следующие параметры:

code – имя класса, содержащего метод init().
archive – имя архива, содержащего апплет (jar-файл).
width – ширина апплета.
height – высота апплета.

В принципе, ограничений на ширину и высоту нет (не допускаются только нулевые или отрицательные размеры). Размер стрелок и чёрточек на циферблате будет автоматически изменён, но делать апплет слишком маленьким просто нет смысла. По моим наблюдениям, при размерах 30х30 ещё что-то можно рассмотреть.

Кстати, высота не обязательно должна быть равна ширине. Если они отличаются, то диаметр циферблата будет выбран равным меньшей стороне, а сам циферблат – отцентрирован относительно большей. Чтобы посмотреть как это работает, задайте размер апплета 700х300 или 100х500.

Следующие пять параметров задают цвета стрелок, циферблата и чёрточек на циферблате.

При этом параметр name указывает название элемента, а параметр value – его цвет.

dialColor – цвет циферблата;
hairLineColor – цвет чёрточек на циферблате;
hoursNeedleColor – цвет часовой стрелки;
minutesNeedleColor – цвет минутной стрелки;
secondsNeedleColor – цвет секундной стрелки.

Как вы, наверное, догадались, цвета задаются в 16-тиричной системе счисления, а цветовая схема – ARGB (alpha, red, green, blue), т.е. первые две цифры задают прозрачность, вторые – красную составляющую цвета, третьи – зелёную, четвёртые – синюю.

При этом FF соответствует максимально насыщенному цвету (или нулевой прозрачности), а 00 – отсутствию данной составляющей в цвете (или 100% прозрачности).

Приведём несколько примеров:

FFFFFFFF – не прозрачный белый цвет;
7F000000 – чёрный цвет (~50% прозрачность);
7F0000FF – синий цвет (~50% прозрачность);
7F00FF00 – зелёный цвет (~50% прозрачность);

Если вы захотите какую-нибудь стрелку сделать не видимой, то просто сделайте первые две цифры равными "00" (100% прозрачность), цвет при этом можно задавать любой (все равно стрелка будет не видна).

Теперь рассмотрим как работает апплет.

При запуске апплета выполняется установка цветов, определение размеров, расчёт размеров стрелок, чёрточек на циферблате и т.д.

Далее нам необходимо с какой-то периодичностью обновлять содержимое апплета (т. е. определять текущее время и поворачивать стрелки). Для этого создаём параллельный поток (timer), который периодически вызывает функцию update().

При каждом обновлении апплета мы определяем время, рассчитываем углы поворота стрелок, и выполняем перерисовку окна апплета. На перерисовке я хочу остановиться подробнее. В принципе, можно рисовать каждую стрелку сразу в окне апплета, но при этом могут возникнуть мерцания. Поэтому лучше использовать следующий приём (т.н. двойную буферизацию): создаём рисунок (объект класса BufferedImage) с размерами апплета, рисуем на нем циферблат, стрелки и др., в окне апплета рисуем уже готовый рисунок.

Кстати, этот апплет использует библиотеку Java2D (пакет java.awt.Graphics2D). Она входит в состав платформы Java 2, т.е. это стандартная библиотека, но некоторые классы появились только в версии 1.4, поэтому с более старыми версиями могут быть проблемы.

Подробнее работа программы описана в комментариях и исходникам.

Скачать:

Исходный код апплета (clock_src.zip – 5,8 кБ)

Стрелочные часы (java-апплет, 6кБ).

Постовой

Интересная и перспективная работа в Украине

Работа в Киеве – множество открытых вакансий