1, 10, 5
1, 10, 70
static boolean compareArrays (int [] ar1, int [] ar2) {
//сравним длины
if (ar1.length != ar2.length )
//return завершает функцию на данном моменте
//мы вернули false, т.к. массивы не равны:
return false;
// если программа дошла до сюда, значит if не сработал, ведь в нем был return
//теперь совершим обход массивов в поисках не равных элементов:
//обычная шапка – идем по обоим массивам вместе:
for (int i = 0; i < ar1.length; i ++)
if (ar1 [i] != ar2 [i]) //если нашли два неравных, то вернуть false
return false;
/*раз ни один из if внутри цикла не сработал и программа до сюда дошла, то
ВСЕ элементы на iых местах в ar1 и ar2 были равны. Смело возвращаем true:*/
return true;
}
//Теперь в main мы можем протестировать эту функцию:
public static void main () {
int [] ar1 = {1, 4, 6};
int [] ar2 = {1, 4, 6};
int [] ar3 = {1, 9, 9};
System.out.println (compareArrays (ar1, ar2));//true-равны
System.out.println (compareArrays (ar2, ar3));//false-неравны
}
for (int i = 0; i < ar1.length; i ++)
if (ar1 [i] != ar2 [i]) //если нашли два неравных, то вернуть false
return false;
else return true; /* ОШИБКА – мы сравним не весь массив, а лишь начальные элементы */
static boolean compareArrays (int [] ar1, int [] ar2) {
//сравним длины
if (ar1.length != ar2.length )
return false;
boolean result = true;
for (int i = 0; i < ar1.length; i ++)
if (ar1 [i] != ar2 [i]) {
result = false;
break; //break останавливает цикл
}
return result;
}
static int[] concatArrays (int [] ar1, int [] ar2) {
//выделим память под новый большой массив-склейку.
int [] ar3 = new int [ar1.length + ar2.length];
//скопируем в начало первый массив в начало второго:
for (int i = 0; i < ar1.length; i ++)
ar3 [i] = ar1 [i];
//скопируем второй массив сразу после первого:
for (int i = 0; i < ar2.length; i ++)
ar3 [ar1.length + i] = ar2 [i]; //следите за тем, чтобы дать нужный номер элемента в квадратных скобках. ar3 приравнивается к ar2
return ar3;
}
//в main сможем использовать так:
public static void main () {
int [] some1 = {1, 2, 3};
int [] some2 = {4, 5, 6};
// вызовем функцию и возвращаемый массив запишем в some3
int [] some3 = concatArrays (some1, some2);
printArray (some3); // будет 1 2 3 4 5 6 – два массива склеены в новом
}
static int[] concatArrays (int [] ar1, int [] ar2) {
//выделим память под новый большой массив-склейку.
int [] ar3 = new int [ar1.length + ar2.length];
//скопируем в начало первый массив в начало второго:
for (int i = 0; i < ar1.length; i ++)
ar3 [i] = ar1 [i];
//скопируем второй массив сразу после первого:
for (int i = 0; i < ar2.length; i ++)
ar3 [ar1.length + i] = ar2 [i]; //следите за тем, чтобы дать нужный номер элемента в квадратных скобках. ar3 приравнивается к ar2
return ar3;
}
//в main сможем использовать так:
public static void main () {
int [] some1 = {1, 2, 3};
int [] some2 = {4, 5, 6};
// вызовем функцию и возвращаемый массив запишем в some3
int [] some3 = concatArrays (some1, some2);
printArray (some3); // будет 1 2 3 4 5 6 – два массива склеены в новом
}
static int searchMin (int [] ar) {
int curMin = ar [0];//быть может нулевой – минимальный?
for (int i = 0; i < ar.length; i ++)
if (ar[i] < curMin) //если есть меньше минимального
curMin = ar [i]; // то мы возьмем новый минимальный
//если мы бы хотели узнать, ГДЕ был минимум, то сохранили бы i
return curMin;
}
static int countSym (char [] str, char sym) {
int count = 0;
for (int i = 0; i < str.length; i ++)
if (str [i] == sym)
count ++;//если нашли символ, то увеличили count
return count;
}
int tmp = ar [i]; //сохранили i-ый элемент в tmp
ar [i] = ar [j]; //мы забыли элемент ar[i], записав в него j-ый
ar[j] = tmp; //записали сохраненное в tmp значение в j-ую ячейку
//подумайте над этим простым алгоритмом. Его нужно хорошо понимать.
static void inverseArray (int [] ar) {
int tmp = 0;
for (int i = 0; i < ar.length/2; i ++) {
//меняем местами элементы под номерам:
//с одной стороны “i”, с другой “ar.length-1-i”
//то есть меняем элементы местами с начала и конца
tmp = ar [i];
ar [i] = ar [ar.length – 1 – i];
ar [ar.length-1-i] = tmp;
}
}
//заметьте, что условие i < ar.length/2 дает нам развернуть массив один раз
// если мы оставим старое i < ar.length, то развернем массив дважды
// и он в итоге останется точно тем же, что и был в начале
//Для запуска этой функции в main сделаем такой код:
public static void main () {
int [] ar1 = {9, 8, 7, 6, 5, 4, 3, 2, 1};
inverseArray (ar1);
printArray (ar1);
}
void increase (int x)
{
x = x +1; //казалось бы икс увеличился на 1
}
public static void main () {
int y = 0;
increase (y);
System.out.println (y);
//как игрек был нулем, так нулем и остался – печально..
}
int [] ar1 = {1, 2, 3};
int [] ar2 = ar1; //присвоена только ссылка, так что реально это тот же массив
ar2 [0] = 10; //изменились оба массива! Не только ar2.
Systtem.out.println (ar1[0]); //распечатается 10, хоть мы и изменили ar2
С переменными примитивных типов другая история – при присваивании копируется значение. Это не ссылки, а просто значения. К этому мы уже и привыкли:
int x = 1;
int y = x;
y = 10;
System.out.println (x); //по-прежнему 10, ведь y с иксом – разные переменные
package javaapplication1;
public class JavaApplication1 {
public static void main(String[] args) {
int x = 100;
x = x*10/2 + x;
System.out.println (x);
double y = x - 5.5;
System.out.println (y);
}
}