Verification: a143cc29221c9be0

Php array количество элементов массива

Php array количество элементов массива

Объявление массива

Переменную массива можно объявить с помощью квадратных скобок:


int[] cats;  // мы объявили переменную массива

Возможна и альтернативная запись:


int cats[]; // другой вариант

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

Мы пока только объявили массив, но на самом деле его ещё не существует, так как не заполнен данными. Фактически значение массива равно null.

Определение массива

После объявления переменной массива, можно определить сам массив с помощью ключевого слова new с указанием типа и размера. Например, массив должен состоять из 10 целых чисел:


cats = new int[10];

Можно одновременно объявить переменную и определить массив (в основном так и делают):


int[] cats = new int[10];

Если массив создаётся таким образом, то всем элементам массива автоматически присваиваются значения по умолчанию. Например, для числовых значений начальное значение будет 0. Для массива типа boolean начальное значение будет равно false, для массива типа char - '\u0000', для массива типа класса (объекты) - null.

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


String[] catNames = new String[10];

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


for (int i = 0; i 

Доступ к элементам массива

Обращение к элементу массива происходит по имени массива, за которым следует значение индекса элемента, заключённого в квадратные скобки. Например, на первый элемент нашего массива cats можно ссылаться как на cats[0], на пятый элемент как cats[4].

В качестве индекса можно использовать числа или выражения, которые создают положительное значение типа int. Поэтому при вычислении выражения с типом long, следует преобразовать результат в int, иначе получите ошибку. С типами short и byte проблем не будет, так как они полностью укладываются в диапазон int.

Инициализация массива

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


int[] cats = {2, 5, 7, 8, 3, 0};  // массив из 6 элементов

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


int[] cats = new int[6]; // массив из шести элементов с начальным значением 0 для каждого элемента
cats[3] = 5; // четвертому элементу присвоено значение 5
cats[5] = 7; // шестому элементу присвоено значение 7

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


int[] mice = {4, 8, 10, 12, 16};
int result = 0;

for(int i = 0; i 

Массив содержит специальное поле length, которое можно прочитать (но не изменить). Оно позволяет получить количество элементов в массиве. Данное свойство удобно тем, что вы не ошибётесь с размером массива. Последний элемент массива всегда mice[mice.length - 1]. Предыдущий пример можно переписать так:


int[] mice = { 4, 8, 10, 12, 16 };
int result = 0;

for (int i = 0; i 

Теперь длина массива вычисляется автоматически, и если вы создадите новый массив из шести котов, то в цикле ничего менять не придётся.

Если вам нужно изменять длину, то вместо массива следует использовать списочный массив ArrayList. Сами массивы неизменяемы.

Будьте осторожны с копированием массивов. Массив - это не числа, а специальный объект, который по особому хранится в памяти. Чтобы не загромождать вас умными словами, лучше покажу на примере.

Допустим, у нас есть одна переменная, затем мы создали вторую переменную и присвоили ей значение первой переменной. А затем проверим их.


int a = 5;
int b = a;
mInfoTextView.setText("a = " + a + "\nb = " + b);

Получим ожидаемый результат.


a = 5
b = 5

Попробуем сделать подобное с массивом.


int[] anyNumbers = {2, 8, 11};
int[] luckyNumbers = anyNumbers;
luckyNumbers[2] = 25;
mInfoTextView.setText("anyNumbers: " + Arrays.toString(anyNumbers)
        + "\nluckyNumbers: " + Arrays.toString(luckyNumbers));

Получим результат.


anyNumbers: [2, 8, 25];
luckyNumbers: [2, 8, 25];

Мы скопировали первый массив в другую переменную и в ней поменяли третий элемент. А когда стали проверять значения у обоих массивов, то оказалось, что у первого массива тоже поменялось значение. Но мы же его не трогали! Магия. На самом деле нет, просто массив остался прежним и вторая переменная обращается к нему же, а не создаёт вторую копию. Помните об этом.

Если же вам реально нужна копия массива, то используйте метод Arrays.copyOf()

Если ваша программа выйдет за пределы индекса массива, то программа остановится с ошибкой времени исполнения ArrayOutOfBoundsException. Это очень частая ошибка у программистов, проверяйте свой код.

Практика

Хватит болтать. Давайте будем проверять все вышесказанное.

Напишем такой код:


public void onClick(View view) {
    int[] cats = new int[6];
    String result = String.valueOf(cats[3]);

    mInfoTextView.setText(result);
}

Запустите приложение и убедитесь, что четвёртому элементу массива cats[3] присвоено значение 0. Проверьте таким образом все элементы массива. Далее присвойте шестому элементу значение 7 и проверьте снова результат.


int[] cats = new int[6];
cats[5] = 7;

String result = String.valueOf(cats[5]);

mInfoTextView.setText(result);

Однако вернёмся к нашей картинке. У всех котов есть имена. Создадим массив из восьми строковых элементов и обратимся к одному из них:


public void onClick(View v) {
	
	String[] catsNames = {
			"Васька", 
			"Кузя",
			"Барсик",
			"Мурзик",
			"Леопольд",
			"Бегемот",
			"Рыжик",
			"Матроскин"
			};
	
	mInfoTextView.setText(catsNames[6]);
}

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

Перебор значений массива

Массивы часто используются для перебора всех значений. Стандартный способ через цикл for


int aNums[] = { 2, 4, 6 };

for (int i = 0; i 

Также есть укороченный вариант записи


for (int num : aNums) {
    String strToPrint = num;
}

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

Многомерные массивы

Для создания многомерных массивов используются дополнительные скобки:


int[][] a = {
        { 1, 2, 3 },
		{ 4, 5, 6 }
}

Также массив может создаваться ключевым словом new:


// трехмерный массив фиксированной длины
int[][][] b = new int[2][4][4];

Двумерный массив

Двумерный массив - это массив одномерных массивов. Если вам нужен двумерный массив, то используйте пару квадратных скобок:


String[][] arr = new String[4][3];

arr[0][0] = "1";
arr[0][1] = "Васька";
arr[0][2] = "121987102";

arr[1][0] = "2";
arr[1][1] = "Рыжик";
arr[1][2] = "2819876107";

arr[2][0] = "3";
arr[2][1] = "Барсик";
arr[2][2] = "412345678";

arr[3][0] = "4";
arr[3][1] = "Мурзик";
arr[3][2] = "587654321";

Представляйте двумерный массив как таблицу, где первые скобки отвечают за ряды, а вторые - за колонки таблицы. Тогда пример выше представляет собой таблицу из четырёх рядов и трёх колонок.

1 Васька 121987102
2 Рыжик 2819876107
3 Барсик 412345678
4 Мурзик 587654321

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


int[][] twoD = new int[3][4]; // объявили двухмерный массив
int i, j, k = 0;

for (i = 0; i 

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

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

[0, 0] [0, 1] [0, 2] [0, 3]
[1, 0] [1, 1] [1, 2] [1, 3]
[2, 0] [2, 1] [2, 2] [2, 3]

Первое число в скобках обозначают ряд (строку), а второе число - столбец. Принято считать, что в массиве new int[M][N] первый размер означает количество строк, а второй - количество столбцов.

На экране после запуска примера мы увидим следующее:


0 1 2 3
4 5 6 7
8 9 10 11

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


int[][] twoD = new int[3][]; // память под первое измерение
// далее резервируем память под второе измерение
twoD[0] = new int[4];
twoD[1] = new int[4];
twoD[2] = new int[4];

В данном примере особого смысла в этом нет.

Еще одна интересная особенность при создании массива связана с запятой. Посмотрите на пример.


int[][] a = {{1, 2, 3}, {4, 0, 0,},};       
System.out.println(Arrays.deepToString(a));  

Вроде в конце используется лишняя запятая, но её наличие не приведёт к ошибке (только одна запятая). Это бывает удобно, когда надо скопировать или вставить кусок массива в коде. Кстати, метод deepToString() класса Arrays очень удобен для вывода двухмерных массивов.

Чтобы совсем сбить вас с толку, приведу ещё один правильный пример.


Integer[] Integer[] = {{1, 2, 3}, {4, 0, 0,},};       
System.out.println(Arrays.deepToString(Integer)); 

Я уже упоминал, что квадратные скобки можно использовать двумя способами. Сначала мы поставили скобки у типа переменной, а потом у имени переменной. При этом мы использовали в качестве имени имя класса Integer. Однако, Java догадывается, что на этот раз используется не класс, а имя и разрешает такой синтаксис. Но лучше так не выпендриваться.

Размер имеет значение

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


int[][] matrix = new int[4][5];
System.out.println(matrix.length);

А если мы хотим узнать количество столбцов в ряду? Тогда указываете ряд, а затем вычисляете у него количество столбцов.


// число колонок у третьего ряда
System.out.println(matrix[2].length);

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

Сложить два массива

Предположим, у вас есть два массива, и вам нужно их соединить и получить общий массив.


private double[] concatArray(double[] a, double[] b) {
	if (a == null)
		return b;
	if (b == null)
		return a;
	double[] r = new double[a.length + b.length];
	System.arraycopy(a, 0, r, 0, a.length);
	System.arraycopy(b, 0, r, a.length, b.length);
	return r;
}

Вместо типа double вы можете использовать другие типы. Вот например, пример сложения двух строковых массивов:


// метод для склеивания двух строковых массивов
private String[] concatArray(String[] a, String[] b) {
	if (a == null)
		return b;
	if (b == null)
		return a;
	String[] r = new String[a.length + b.length];
	System.arraycopy(a, 0, r, 0, a.length);
	System.arraycopy(b, 0, r, a.length, b.length);
	return r;
}

String[] week1 = new String[] { "Понедельник", "Вторник", "Среда" };

String[] week2 = new String[] { "Четверг", "Котопятница", "Субкота",
			"Воскресенье" };
			
String[] week = concatArray(week1, week2); // будет возвращён массив всех семи дней недели

Взять часть массива

Аналогично, если вам нужно взять только часть из большого массива, то воспользуйтесь методом:


// start - с какой позиции нужно получить новый массив, отсчёт с 0
private double[] copyPartArray(double[] a, int start) {
	if (a == null)
		return null;
	if (start > a.length)
		return null;
	double[] r = new double[a.length - start];
	System.arraycopy(a, start, r, 0, a.length - start);
	return r;
}

public void onClick(View v) {
	double[] digits = new double[] {6.5, 3.1, 5.72};
	double[] part = copyPartArray(digits, 1);
	Toast.makeText(v.getContext(), part[1] + "", Toast.LENGTH_LONG).show();
}

Здесь вы также можете использовать другие типы вместо double. Вот пример использования:


private String[] copyPartArray(String[] a, int start) {
	if (a == null)
		return null;
	if (start > a.length)
		return null;
	String[] r = new String[a.length - start];
	System.arraycopy(a, start, r, 0, a.length - start);
	return r;
}

public void onClick(View v) {
	String[] weekday = new String[] { "Понедельник", "Вторник", "Среда" };

	// нам нужен массив со второго элемента
	String[] week = copyPartArray(weekday, 1); // вернёт Вторник и Среда
	// выводим второй элемент из полученного массива, т.е. Среда
	Toast.makeText(v.getContext(), week[1], Toast.LENGTH_LONG).show();
}

Перемешать элементы массива

Бывает необходимость перемешать элементы массива в случайном порядке. В интернете нашёл готовый метод по алгоритму Fisher–Yates (прим.: Fisher - это рыбак, который ловит рыбу, например, кот)


// Implementing Fisher–Yates shuffle
static void shuffleArray(int[] ar) {
	Random rnd = new Random();
	for (int i = ar.length - 1; i > 0; i--) {
		int index = rnd.nextInt(i + 1);
		// Simple swap
		int a = ar[index];
		ar[index] = ar[i];
		ar[i] = a;
	}
}

// создадим массив и перемешаем его
int[] mSolutionArray = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
		13, 14 };
shuffleArray(mSolutionArray);

Log.i("Array", Arrays.toString(mSolutionArray));

Подводим итоги

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

При выходе за границу массива происходит исключение RuntimeException, свидетельствующее об ошибке программиста.

Метод arraycopy() - Копирование массива

Стандартная библиотека Java содержит статический метод System.arraycopy(), который копирует массивы значительнее быстрее, чем при ручном копировании в цикле for.

В аргументах arraycopy() передаётся исходный массив, начальная позиция копирования в исходном массиве, приёмный массив, начальная позиция копирования в приёмном массиве и количество копируемых элементов. Любое нарушение границ массива приведёт к исключению.

Разработчик Avi Yehuda написал программу, которая вычисляет время на копирование с помощью цикла for и с помощью метода arraycopy() на примере с миллионом элементов. Ручное копирование у него заняло 182 мс, с помощью метода arraycopy() - 12 мс. Разница колоссальна.


public class ArrayCopyTestActivity extends Activity {
    private static final int SIZE_OF_ARRAY = 1000000;
	private long time;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        Integer [] sourceArray = new Integer[SIZE_OF_ARRAY];
        Integer [] dst = new Integer[SIZE_OF_ARRAY];
        fillArray(sourceArray);
        
        startBenchmark();
        naiveCopy(sourceArray,dst);
        stopBenchmark();
       
        startBenchmark();
        System.arraycopy(sourceArray, 0, dst, 0, sourceArray.length);
        stopBenchmark();
    }

	private void naiveCopy(Integer [] src, Integer [] dst) {
		for (int i = 0; i 

Поиск элементов строкового массива по начальным символам

Допустим, у нас есть строковый массив и нам нужно по первым символам найти все слова, которые входят в данный массив.


// Сам метод
public static ArrayList searchFromStart(String[] inputArray, String searchText) {
    ArrayList outputArray = new ArrayList();

    for (int i = 0; i  words = searchFromStart(catNamesArray, "мур");
Toast.makeText(getApplicationContext(), words.get(0).toString() + ":" + words.get(1).toString(), Toast.LENGTH_SHORT).show();

Вернёт списочный массив из двух элементов: Мурзик и Мурка.

Класс Arrays

Класс java.util.Arrays предназначен для работы с массивами. Он содержит удобные методы для работы с целыми массивами:

  • copyOf() − предназначен для копирования массива
  • copyOfRange() − копирует часть массива
  • toString() − позволяет получить все элементы в виде одной строки
  • sort() — сортирует массив методом quick sort
  • binarySearch() − ищет элемент методом бинарного поиска
  • fill() − заполняет массив переданным значением (удобно использовать, если нам необходимо значение по умолчанию для массива)
  • equals() − проверяет на идентичность массивы
  • deepEquals() − проверяет на идентичность массивы массивов
  • asList() − возвращает массив как коллекцию

Сортировка массива

Сортировка (упорядочение по значениям) массива a производится методами Arrays.sort(a) и Arrays.sort(a, index1, index2). Первый метод упорядочивает в порядке возрастания весь массив, второй — часть элементов (от индекса index1 до индекса index2). Имеются и более сложные методы сортировки. Элементы массива должны быть сравниваемы (поддерживать операцию сравнения).

Простой пример


// задаём числа в случайном порядке
int[] numbers = new int[]{1, 23, 3, 8, 2, 4, 4};
// сортируем
Arrays.sort(numbers);
// проверяем
mInfoTextView.setText(Arrays.toString(numbers));

Сортировка массива для ArrayAdapter

Массивы часто используются в адаптерах для заполнения данными компоненты Spinner, ListView и т.п.

Предположим, у вас есть массив строк и его нужно отсортировать перед отдачей массива адаптеру ArrayAdapter. Это позволит вывести строки в упорядоченном виде, например, в ListView:


String[] catsNames = {
		"Васька", 
		"Кузя",
		"Барсик",
		"Мурзик",
		"Леопольд",
		"Бегемот",
		"Рыжик",
		"Матроскин"
		};
// Сортируем перед передачей адаптеру		
Arrays.sort(catsNames);

ArrayAdapter adapter;
 
adapter = new ArrayAdapter(
		this,
		android.R.layout.simple_list_item_1,
		catsNames);
 
setListAdapter(adapter);

У метода sort() есть перегруженные версии, где можно указать диапазон массива, в пределах которого следует произвести сортировку.

Копирование массивов

Метод Arrays.copyOf(оригинальный_массив, новая_длина) — возвращает массив-копию новой длины. Если новая длина меньше оригинальной, то массив усекается до этой длины, а если больше, то дополняется нулями.


// первый массив
int[] anyNumbers = {2, 8, 11};
// копия второго массива
int[] luckyNumbers = Arrays.copyOf(anyNumbers, anyNumbers.length);
luckyNumbers[2] = 25;
mInfoTextView.setText("anyNumbers: " + Arrays.toString(anyNumbers)
        + "\nluckyNumbers: " + Arrays.toString(luckyNumbers));

Теперь первый массив останется без изменений, а со вторым массивом делайте что хотите. Смотрим на результат.


anyNumbers: [2, 8, 11];
luckyNumbers: [2, 8, 25];

Можно создать увеличенную копию, когда копируются все значения из маленького массива, а оставшиеся места заполняются начальными значениями, например, нулями.


// три элемента
int[] small_array = {1, 2, 3};
// создадим массив с пятью элементами
int[] big_array = Arrays.copyOf(small_array, 5);
mInfoTextView.setText("big_array: " + Arrays.toString(big_array));

Получим результат:


big_array: [1, 2, 3, 0, 0]

Метод Arrays.copyOfRange(оригинальный_массив, начальный_индекс, конечный_индекс) — также возвращает массив-копию новой длины, при этом копируется часть оригинального массива от начального индекса до конечного –1.


// Массив из четырёх элементов
String[] array_1 = {
        "Васька",
        "Мурзик",
        "Рыжик",
        "Барсик"};
// Сортировка массива
Arrays.sort(array_1);
// Копируем первые три элемента массива во второй массив
String[] array_2 = Arrays.copyOf(array_1, 3);
// Копируем нужные элементы из первого массива
// в диапазоне от второго элемента до последнего в третий массив
String[] array_3 = Arrays.copyOfRange(array_1,
        2, array_1.length);

Log.i(TAG, Arrays.toString(array_1));
Log.i(TAG, Arrays.toString(array_2));
Log.i(TAG, Arrays.toString(array_3));

Метод Arrays.toString()

Если использовать вызов метода toString() непосредственно у массива, то получите что-то непонятное и нечитаемое.


String[] catNames = {
        "Васька",
        "Мурзик",
        "Рыжик",
        "Барсик"};
Log.i(TAG, catNames.toString());

// Вернёт
[Ljava.lang.String;@4222bd88

Метод Arrays.toString(массив) возвращает строковое представление массива со строковым представлением элементов, заключённых в квадратные скобки. В примерах выше мы уже вызывали данный метод.

Метод deepToString() удобен для вывода многомерных массивов. Этот метод мы также уже использовали выше.

Метод Arrays.fill() - наполнение массива одинаковыми данными

Метод Arrays.fill() позволяет быстро заполнить массив одинаковыми значениями. У метода есть восемнадцать перегруженных версий для разных типов и объектов.

Метод fill() просто дублирует одно заданное значение в каждом элементе массива (в случае объектов копирует одну ссылку в каждый элемент):


int size = 4;
boolean[] test1 = new boolean[size];
int[] test2 = new int[size];
String[] test3 = new String[size];
Arrays.fill(test1, true); // присваивем всем true
Toast.makeText(getApplicationContext(), Arrays.toString(test1),
		Toast.LENGTH_LONG).show();
Arrays.fill(test2, 9); // присваиваем всем 9
Toast.makeText(getApplicationContext(), Arrays.toString(test2),
		Toast.LENGTH_LONG).show();
Arrays.fill(test3, "Мяу!"); // Ну вы поняли
Toast.makeText(getApplicationContext(), Arrays.toString(test3),
		Toast.LENGTH_LONG).show();

Запустив код, вы увидите, что на экране по очереди выводятся значения:

[true, true, true, true]
[9, 9, 9, 9]
[Мяу!, Мяу!, Мяу!, Мяу!]

Можно заполнить данными в нужном интервале за два прохода:


int size = 4;
String[] test3 = new String[size];
Arrays.fill(test3, "Мяу! ");
Arrays.fill(test3, 2, 3, "Гав!");
Toast.makeText(getApplicationContext(), Arrays.toString(test3),
		Toast.LENGTH_LONG).show();

Сначала массив заполнится мяуканьем кота 4 раза, а потом на третью позицию попадает слово Гав!:

[Мяу!, Мяу!, Гав!, Мяу!]

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

Метод equals() - сравнение массивов

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

Напишем код в своей учебной программе.


// Создаем два массива
int[] a1 = new int[10];
int[] a2 = new int[10];
// заполняем их девятками
Arrays.fill(a1, 9);
Arrays.fill(a2, 9);
mInfoTextView.setText("Сравним: " + Arrays.equals(a1, a2));

Мы создали два массива и заполнили их одинаковыми числами. При сравнении мы получим true. Добавим в код строчку кода, которая заменит один элемент во втором массиве:


//Изменим один элемент у второго массива
a2[3] = 11;
mInfoTextView.setText("Сравним: " + Arrays.equals(a1, a2));

Теперь при сравнении будет выдаваться false.

Задачи

Решите задачи. Ответы доступны зарегистрированным пользователям.

Имеется массив из четырёх чисел int[] numbers = {3, 9, 11, 15};. Поменяйте местами первый и второй элемент массива. (Ответ)

Создайте массив из всех чётных чисел от 2 до 30 и выведите элементы массива на экран.

Создайте массив из всех нечётных чисел от 1 до 99, выведите его на экран в строку, а затем этот же массив выведите на экран тоже в строку, но в обратном порядке (99 97 95 93 … 7 5 3 1).

Создайте массив из 20-ти первых чисел Фибоначчи и выведите его на экран. Напоминаем, что первый и второй члены последовательности равны единицам, а каждый следующий — сумме двух предыдущих.

Найти максимальное значение из массива

Задача: Имеется статистика, сколько мышей поймал кот Барсик за год по месяцам в виде массива:


int[] mice = new int[] { 4, 9, 3, 22, 5, 18, 25, 7, 11, 15, 5, 19 };

Написать метод getMax(), который вычисляет максимальное значение из массива. Ну и метод getMin() для нахождения минимального значения.

Ответ

Найти три наибольших числа из массива

Похожая задача - найти три наибольших числа из массива mice (предыдущая задача).

Ответ

Перестановка элементов массива в обратном порядке

Задача: Имеется массив, нужно переставить элементы массива в обратном порядке.


int[] mice = new int[] { 4, 9, 3, 22, 5, 18, 25, 7, 11, 15, 5, 19 };

Ответ

Поместить нули в конец массива

Дан массив с числами 5, 4, 3, 0, 6, 0, 0, 5, 6, 0, 25, 0, 8, 7, 3, 0, 1, 1, 0, 6, 4. Переместить все нули в конец массива.

Ответ

Поместить нули в начало массива

Дан массив с числами 5, 4, 3, 0, 6, 0, 0, 5, 6, 0, 25, 0, 8, 7, 3, 0, 1, 1, 0, 6, 4. Переместить все нули в начало массива.

Ответ

Найти индекс числа из массива

Есть массив, нужно определить индекс числа, который входит в этот массив.

Ответ

Синтаксис:

Цикл foreach можно использовать только для чтения значений массива или обоих ключей и значений массива.

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

foreach(($array as $value) {
// операторы
}

Следующий цикл foreach используется для чтения значений элементов массива. В основном он используется для чтения ассоциативных массивов. На каждой итерации цикла каждый ключ и значение массива будут храниться в двух переменных.

 foreach(($array as $key => $element) {
// операторы
}

Пример 1: чтение числового массива

В следующем примере показан способ чтения числового массива с помощью цикла foreach. Создайте файл PHP со следующим скриптом.

В скрипте объявляется числовой массив с именем $num_array из 10 элементов, а для хранения четных чисел из числового массива объявляется пустой массив с именем $new_array. Цикл foreach используется для перебора числового массива, а условие if используется для определения четных чисел из массива $num_array и сохранения всех четных чисел в массиве $new_array. Другой цикл foreach используется для печати значений $num_array.

";
/ * Итерируем числовой массив, чтобы найти числа, делящиеся на 5 и сохранить в новом массиве * /
foreach($num_array as $value){
if($value%5 == 0)
{
$new_array[$index]= $value;
$index++;
}
echo $value." ";
}

echo "

Список чисел, которые делятся на 5:
"; // Распечатать значения массива $new_array foreach($new_array as $value){ echo $value." "; } ?>

Вывод:

Вывод появится после запуска сценария с сервера. Выходные данные показывают, что в числовом массиве четыре четных числа.

Пример 2: чтение ассоциативного массива

В следующем примере показан способ чтения ассоциативного массива и сохранения определенных ключей из одного массива в другой с помощью цикла foreach. Здесь ассоциативный массив с именем $members содержит имя члена в качестве ключа и «Present» или « Absent» в качестве значения массива. Пустой массив с именем $present_member используется для хранения имен присутствующих членов. Затем цикл foreach используется для печати значений $present_member.

 'Present', 'Alex Master' => 'Absent', 
'Maxim Kamerrer' => 'Present');
// Объявить пустой массив
$present_members = array();
// Инициализируем индекс для массива
$index = 0;

foreach ($members as $key => $value) { 
if(($value == 'Present')){
$present_members[$index]= $key;
$index ++;
}
}

// Подсчитываем общее количество присутствующих участников
$count = count($present_members));

echo " $count участников.  

"; echo " Участники:
"; foreach(($present_members as $value)){ echo $value."
"; } ?>

Вывод:

Вывод появится после запуска сценария с сервера. Ассоциативный массив содержит три текущих значения и два отсутствующих значения. Для этого в выходных данных отображаются имена трех присутствующих членов из массива $members.

Пример 3: чтение свойств объектной переменной

В следующем примере показан способ чтения имен свойств и значений любого объекта. Создайте файл PHP со следующим скриптом.

Класс с именем Customer определен в сценарии, который содержит три общедоступных свойства со значениями. Затем создается переменная $object для доступа к свойствам класса. Переменная объекта может быть проанализирована как ассоциативный массив, используя цикл foreach. Здесь цикл foreach используется для чтения имени свойства и значения свойства объектной переменной $object. Каждое имя свойства и значение объекта $ будут считываться на каждой итерации цикла и печататься в каждой строке.

 Сведения о клиенте: ";
foreach($object as $property => $value)
{
echo " $property = $value 
"; }?>

Вывод:

Вывод появится после запуска сценария с сервера. Класс Customer содержит три свойства: имя, адрес электронной почты и телефон. Эти свойства инициализируются значениями внутри класса. На выходе печатаются имена и значения свойств.

Синтаксис и использование функции count()

Результат функции - количество элементов, содержащихся в массиве, которые переданы в качестве параметра. Ниже представлен пример PHP: подсчет количества элементов в массиве.

Первоначально был создан массив из 13 случайных элементов. Каждый элемент - строка символов различного содержания и длины. Затем было удалено два элемента и добавлен один. По логике 13 - 2 + 1 = 12, но функция count() считает иначе. Ниже приведен код вывода этого результата.

Поскольку был добавлен массив, то число элементов должно было увеличиться на количество элементов этого массива. Понятно, что цель функции count() - посчитать количество элементов в массиве. PHP меньше всего интересует, что элементами массива могут быть тоже массивы. Но в прикладном отношении далеко не всегда элементы массива включают в себя разнородные другие массивы.

Особенности структурирования данных

Если речь идет об обработке данных по поставке фруктов в магазин, то элементом может быть ананас и различные сорта яблок или груш. Заводить на все три позиции ассортимента три различных структуры данных нецелесообразно по множеству причин.

Один массив будет всегда лучшим решением, но в нем может быть как строчная строка - «ананас», так и совокупность строк - «сорт яблок» или «сорт груш». Строк может быть множество, все зависит от:

  • даты поставки;
  • сорта;
  • количества;
  • цены и др.

Но смысл строки всего массива и строки подмассива всегда будет один. В таком представлении данных количество элементов в массиве PHP не определить по своей логике. Здесь массив должен иметь собственный функционал для определения количества. Функции count() не свойственна рекурсия, и ее использование для определения точного количества элементов - не гарантия точного результата.

Объекты и массивы

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

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

Представим ассортимент как объект, в который входят:

  • фрукты;
  • овощи;
  • возможность добавления любого товара.

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

Компьютеры

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

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

Синтаксис и использование функции count()

Результат функции - количество элементов, содержащихся в массиве, которые переданы в качестве параметра. Ниже представлен пример PHP: подсчет количества элементов в массиве.

Первоначально был создан массив из 13 случайных элементов. Каждый элемент - строка символов различного содержания и длины. Затем было удалено два элемента и добавлен один. По логике 13 - 2 + 1 = 12, но функция count() считает иначе. Ниже приведен код вывода этого результата.

Поскольку был добавлен массив, то число элементов должно было увеличиться на количество элементов этого массива. Понятно, что цель функции count() - посчитать количество элементов в массиве. PHP меньше всего интересует, что элементами массива могут быть тоже массивы. Но в прикладном отношении далеко не всегда элементы массива включают в себя разнородные другие массивы.

Особенности структурирования данных

Если речь идет об обработке данных по поставке фруктов в магазин, то элементом может быть ананас и различные сорта яблок или груш. Заводить на все три позиции ассортимента три различных структуры данных нецелесообразно по множеству причин.

Один массив будет всегда лучшим решением, но в нем может быть как строчная строка - «ананас», так и совокупность строк - «сорт яблок» или «сорт груш». Строк может быть множество, все зависит от:

  • даты поставки;
  • сорта;
  • количества;
  • цены и др.

Но смысл строки всего массива и строки подмассива всегда будет один. В таком представлении данных количество элементов в массиве PHP не определить по своей логике. Здесь массив должен иметь собственный функционал для определения количества. Функции count() не свойственна рекурсия, и ее использование для определения точного количества элементов - не гарантия точного результата.

Объекты и массивы

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

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

Представим ассортимент как объект, в который входят:

  • фрукты;
  • овощи;
  • возможность добавления любого товара.

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

Актуально

Разное
Разное

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

Организация массива

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

Ключ Значение
breakfast 700
dinner 1500
supper 1100

Массив может иметь только один элемент с заданным ключом, т.е. в приведённом выше массиве не может быть двух элементов с ключом dinner. При попытке «добавить» второй dinner, мы просто перезапишем значение уже существующего элемента. В данном примере мы рассмотрели наиболее частый случай организации массива, а именно в виде ассоциативного. Ассоциативный массив удобнее использовать в коде, т.к. его ключи имеют осмысленные наименования (ассоциируются с какими-то частями приложения или данными которые обрабатывает скрипт). Но есть более простой пример массив, это числовые массивы. При их создании не нужно указывать ключ, он задаётся автоматически в виде целого числа, начиная с нуля.

Ключ Значение
0 700
1 1500
2 1100

Рассмотрим пример:


//Пример создания ассоциативного массива
$menuPrice = [
    'breakfast' => 700,
    'dinner' => 1500,
    'supper' => 1100
];

//Пример создания «числового» массива
$prices = [700, 1500, 1100];

В первом случае элементы массива представляют из себя пару ключ-значение, где в качестве ключа используются строковые названия «блюд» (приёмов пищи на самом деле, но пусть будет блюд), а значение это цена блюда. Во втором же случае я указал только цены, при этом интерпретатор PHP автоматически проставит ключи элементам массива.

Операции с массивами

Один из случаев ключевой операции с массивами, а именно его создание мы рассмотрели выше. А как ещё можно создать массив? Самый простой случай, это создание пустого массива:


//Создаём пустой массив
$array = [];

Создание и модификация массива

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

Вы так же можете заполнить массив на лету, например данными из базы данных:


//Заполняем массив данными из БД
$users = [];
//...некая выборка значения, например пользователей users
while($user = $db->query('SELECT * FROM users')->fetch(PDO::FETCH_ASSOC)){
    $users[] = $user;
}

Перебор массивов

С другой стороны готовый массив можно перебрать и например вывести его элементы на экран:


//Перебор массива
$week = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье'];

//Выведем список дней недели
echo '
    '; foreach ($week as $key => $day) { echo '
  • '. $day .'
  • '; } echo '
';

Вообще в php существует больше 70 функций для работы с массивами, однако в большинстве случаев вы будет использовать не больше двадцати. Приведу некоторые из них:

  • in_array — проверяет присутствие элемента в массиве
  • key_exists  — проверяет присутствует ли в массиве указанный ключ или индекс
  • array_search  — осуществляет поиск заданного значения в массиве и возвращает ключ первого найденного значения
  • array_merge — объединяет 2 и более массивов в один
  • array_chunk — разбивает массив на части

Сортировка массива

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


//Пользовательская функция сравнения элементов массива
function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a 

В результате выполнения данного примера получим такой массив:


array(5) {
  [0]=>int(1)
  [1]=>int(2)
  [2]=>int(3)
  [3]=>int(5)
  [4]=>int(6)
}

Как вы понимаете данный пример максимально упрощён. Но внутри вашей функции compare() можно реализовать любой алгоритм сравнения элементов. Главное правильно возвращать значение, ноль — если элементы не отличаются и их не надо менять местами и 1 или -1 если нужно изменить порядок элементов.

Вы так же можете пробросить в тело функции compare() внешнюю переменную используя анонимную функцию и ключевое слово use:


//Пользовательская функция сравнения элементов массива
$params = ['min_value'=>0, 'max_value'=>3];
function compare($params){
    return function ($a, $b) use ($params)
    {
        if ($a == $b) {
            return 0;
        }

        if($a = $params['min_value'] && $a 

Как видите теперь compare() принимает параметры $params и возвращает анонимную функцию в которой уже реализован ваш алгоритм сравнения в котором используются переданные параметры. Результат при таком алгоритме изменится:


array(5) {
  [0]=>int(1)
  [1]=>int(2)
  [2]=>int(3)
  [3]=>int(6)
  [4]=>int(5)
}

Грубо говоря сортировка по возрастанию шла пока значение $a попадало в диапазон от 0 до 3-х.

Глобальные массивы

В PHP начиная с версии 4 ввели такой сущность как «суперглобальные массивы». Это особые переменные доступные в любой части приложения и содержат информацию, например о состоянии сервера (массив $_SERVER) сессии, куках или переданных от пользователя запросах, одним словом о состоянии среды выполнения приложения. На данный момент в PHP доступно девять суперглобальных массивов:

Наименование Описание массива
$GLOBALS Этот массив содержим все переменные объявленные в скрипте, при этом имена переменных являются ключами этого массива.
$_SERVER Данный массив содержит всю информацию о сервере, а так же настройки среды в которой выполняется скрипт
$_GET Массив переменных переданных PHP скрипту по средствам GET запроса (через адресную строку браузера или другими методами, например curl())
$_POST Так же как и GET содержит переданные скрипту переменные, только уже методом POST
$_COOKIE Содержим coockies-ы пользователя
$_REQUEST Объединяет в себе массивы $GET, $POST и $COOKIE. Не рекомендуется использовать, не безопасно, хотя и удобно.
$_FILES Содержим список файлов загружаемых на сервер через веб-формы (имя, временный путь, размеры и т.д.)
$_ENV Содержит переменные окружения в котором запущен PHP скрипт
$_SESSION В данном массиве содержаться все переменные сессии текущего пользователя

 Чаще всего, вы будете сталкиваться с массивами $_GET и $_POST т.к. с их помощью в скрипты на сервере передаются данные от клиентской части (через веб-формы).

Инициализация (очистка) массива.

Реализация

    my @array = ();

Реализация

$#array - это индекс (порядковый номер) последнего элемента массива (на единицу меньше, чем количество элементов в массиве, так как массив начинается с нуля). Присвоение $#array изменяет длину массива @array, таким образом вы можете уничтожить (или очистить) все элементы массива между заданным при присвоении и последним. При присвоении -1, все элементы уничтожаются и массив очищается. Я рекомендую следующее решение:

    $#array = -1;

Определение существования элемента массива

Реализация

    print "Значение СУЩЕСТВУЕТ, но может быть неопределенно.\n"
    if exists $array[ $index ];

    print "Значение ОПРЕДЕЛЕНО, но может быть false.\n"
    if defined $array[ $index ];

    print "Зачениие элемента с индексом $index TRUE.\n"
    if $array[ $index ];

Задача

Необходимо определить совокупность всех комбинаций множеств, содержащих все или некоторые элементы массива, известную также как показательное множество.

Решение

Используем функцию pc_array_power_set():

function pc_array_power_set($array) {
       // инициализируем пустым множеством
       $results = array(array());

       foreach ($array as $element)
              foreach ($results as $combination)
                     array_push($results, array_merge(array($element), $combination));

       return $results;
}

Она возвращает массив массивов, содержащий все комбинации элементов, включая пустое множество. Например:

$set = array('A' , 'B' , 'C');
$power_set = pc_array_power_set($set);

Массив $power_set состоит из восьми массивов:

array();
array('A');
array('B');
array('C');
array('A' , 'B');
array('A' , 'C');
array('B' , 'C');
array('A' , 'B' , 'C');

Синтаксис

count(массив);

Узнать длину строки в PHP

Первая функция, которая будет вычислять длину строки в PHP, будет strlen.

1
2
3
$str = "Hello World";
echo strlen($str);
// 11 символов вместе с пробелом

А если мы напишем примерно то же самое, но на русском, то получим такой вариант:

1
2
3
$str = "Привет Мир";
echo strlen($str);
// 19 символов вместе с пробелом

В этом случае, как я уже говорил ранее, каждый символ займет 2 байта + 1 байт — это пробел. В итоге мы получим не совсем то, что ожидали. Поэтому в случае с кириллицей, чтобы определить длину строки, следует использовать другие функции. Первая — mb_strlen

1
2
3
$str = "Привет Мир";
echo mb_strlen($str);
// 10 символов вместе с пробелом

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

1
2
3
$str = "Привет Мир";
echo iconv_strlen($str);
// 10 символов вместе с пробелом

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

echo iconv_strlen($str, "UTF-8");

Если возникла необходимость проверить длину строки без пробелов, то потребуется дополнительная функция str_replace

1
2
3
4
$str = "Привет Мир";
echo iconv_strlen(str_replace(' ', '', $str));
// 9 символов без пробелов
//iconv_strlen или mb_strlen