ניתוח שאלות ותשובות מראיונות למפתח Java. חלק 13

שלום! תנועה לעבר מטרה היא, קודם כל, תנועה. לכן, לא מספיק רק לחשוב שאתה רוצה להשיג משהו. אתה צריך לעשות משהו - אפילו את הצעדים הכי קטנים - אבל לעשות אותם כל יום, ורק כך תשיג את המטרה הסופית. ומכיוון שאתה כאן כדי להפוך למפתחי Java, אתה צריך לקחת לפחות צעד מינימלי לקראת העמקת הידע שלך בג'אווה מדי יום. לשלב הג'אווה של היום, אני מציע לך להכיר את החלק החדש של הניתוח של שאלות הראיונות הפופולריות ביותר למפתחים. היום נעבור על החלק המעשי של השאלות למומחים ג'וניור. משימה מעשית בראיון אינה נדירה. חשוב לא ללכת לאיבוד במצב כזה, לנסות לשמור על קור רוח ולהציע את הפתרון האופטימלי, או אפילו כמה. הייתי ממליץ גם לא לשתוק בעת פתרון בעיה, אלא להעיר על הלך המחשבה שלך ולכתוב את הפתרון, או לאחר הכתיבה, להסביר במילים מה עשית ולמה. זה יחבב אותך על המראיין הרבה יותר מאשר החלטה שקטה. אז בואו נתחיל!

111. איך מחליפים נתונים בין שרשורים?

כדי להחליף נתונים בין שרשורים, אתה יכול להשתמש בהרבה גישות ואמצעים שונים: לדוגמה, השתמש במשתנים אטומיים, אוספים מסונכרנים וסמפור. אבל כדי לפתור בעיה זו, אתן דוגמה עם Exchanger . Exchanger הוא מחלקת סנכרון מהחבילה במקביל המאפשרת החלפת אלמנטים בין זוג חוטים על ידי יצירת נקודת סנכרון משותפת. השימוש בו מפשט את חילופי הנתונים בין שני שרשורים. הדרך שבה זה עובד היא די פשוטה: היא ממתינה לשני שרשורים נפרדים כדי לקרוא לשיטת exchange() שלו . נוצר ביניהם משהו כמו נקודת החלפה: החוט הראשון שם את החפץ שלו ומקבל את החפץ של האחר בתמורה, והאחרון, בתורו, מקבל את החפץ של הראשון ומניח את שלו. כלומר, השרשור הראשון משתמש בשיטת exchange() והוא לא פעיל עד שרשור אחר קורא לשיטת exchange() על אותו אובייקט והחלפת נתונים ביניהם. כדוגמה, שקול את היישום הבא של מחלקת Thread :

public class CustomThread extends Thread {
 private String threadName;
 private String message;
 private Exchanger<String> exchanger;

 public CustomThread(String threadName, Exchanger<String> exchanger) {
   this.threadName = threadName;
   this.exchanger = exchanger;
 }

 public void setMessage(final String message) {
   this.message = message;
 }

 @Override
 public void run() {
   while (true) {
     try {
       message = exchanger.exchange(message);
       System.out.println(threadName + " поток получил сообщение: " + message);
       Thread.sleep(1000);
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }
}

ב-thread constructor, אנו מגדירים אובייקט Exchanger שמקבל אובייקטים מסוג String , ובהפעלה (בשיטת run ) אנו משתמשים ב-change() שלו כדי להחליף הודעה עם שרשור אחר שמשתמש בשיטה זו באותו Exchanger . בוא נריץ את זה ב- main :

Exchanger<String> exchanger = new Exchanger<>();
CustomThread first = new CustomThread("Первый ", exchanger);
first.setMessage("Сообщение первого потока");
CustomThread second = new CustomThread("Второй", exchanger);
second.setMessage("Сообщение второго потока");
first.start();
second.start();

הקונסולה תציג: המשמעות היא שחילופי נתונים בין שרשורים מצליחים.

112. מה ההבדל בין המחלקה Thread לבין ממשק Runnable?

הדבר הראשון שאציין הוא ש- Thread הוא מחלקה, Runnable הוא ממשק, וזה הבדל מאוד ברור =D אני גם אגיד ש- Thread משתמש ב-Runnable (קומפוזיציה). כלומר, יש לנו שתי דרכים:

1. יורש מ- Thread , עוקף את שיטת הריצה, ואז צור את האובייקט הזה והתחל את השרשור באמצעות המתודה start() .

2. יישם Runnable במחלקה מסוימת, יישם את שיטת run() שלו ולאחר מכן צור אובייקט Thread , הקצאת יישום אובייקט זה של ממשק Runnable לבנאי שלו . ובכן, בסוף, הפעל את אובייקט Thread באמצעות שיטת start() .

מה עדיף? בואו נחשוב קצת:

• כאשר אתה מיישם את ממשק ההפעלה , אתה לא משנה את התנהגות השרשור. בעצם אתה רק נותן לשרשור משהו להפעיל. וזהו ההרכב שלנו, שבתורו נחשב לגישה טובה.

• יישום Runnable נותן יותר גמישות לכיתה שלך. אם אתה יורש מ- Thread , אז הפעולה שתבצע תמיד תהיה בשרשור. אבל אם אתה מיישם Runnable זה לא חייב להיות רק שרשור. אחרי הכל, אתה יכול להפעיל אותו בשרשור או להעביר אותו לשירות executor כלשהו. ובכן, או פשוט להעביר את זה איפשהו כמשימה באפליקציה עם חוט יחיד.

• השימוש ב- Runnable מאפשר לך להפריד באופן הגיוני בין ביצוע משימה לבין לוגיקה של בקרת חוטים.

• ב-Java, רק ירושה בודדת אפשרית, כך שניתן להרחיב רק מחלקה אחת. יחד עם זאת, מספר הממשקים הניתנים להרחבה הוא בלתי מוגבל (טוב, לא ממש בלתי מוגבל, אבל 65535 , אבל לא סביר שתגיעו למגבלה הזו אי פעם).

ובכן, זה תלוי בך להחליט במה בדיוק עדיף להשתמש ^^

113. ישנם חוטים T1, T2 ו-T3. איך ליישם אותם ברצף?

הדבר הראשון והפשוט ביותר שעולה בראש הוא שימוש בשיטת join() . זה משעה את הביצוע של השרשור הנוכחי (שנקרא השיטה) עד שהשרשור שבו נקראה השיטה יסיים את הביצוע. בואו ניצור יישום שרשור משלנו:

public class CustomThread extends Thread {
private String threadName;

 public CustomThread(final String  threadName){
   this.threadName = threadName;
 }

 @Override
 public void run() {
   System.out.println(threadName + " - начал свою работу");
   try {
     // происходит некая логика
     Thread.sleep(1000);
   } catch (InterruptedException e) {
     e.printStackTrace();
   }

   System.out.println(threadName + " - закончил свою работу");
 }
}

בואו נתחיל שלושה שרשורים כאלה אחד אחד באמצעות join() :

CustomThread t1 = new CustomThread("Первый поток");
t1.start();
t1.join();
CustomThread t2 = new CustomThread("Второй поток");
t2.start();
t2.join();
CustomThread t3 = new CustomThread("Третий поток");
t3.start();
t3.join();

פלט מסוף: זה אומר שהשלמנו את המשימה שלנו. לאחר מכן, אנו עוברים ישירות למשימות מעשיות ברמת הג'וניור .

משימות מעשיות

114. סכום אלכסוני מטריקס (בעיית Leetcode)

תנאי: חשב את סכום כל האלמנטים באלכסון הראשי וכל האלמנטים באלכסון הנוסף שאינם חלק מהאלכסון הראשי. 1. עם מטריצה ​​של הצורה: mat = [[1,2,3], [4,5,6], [7,8,9]] הפלט צריך להיות - 25 2. עם מטריצה ​​- mat = [[1,1 ,1,1], [1,1,1,1], [1,1,1,1], [1,1,1,1]] הפלט צריך להיות - 8 3. עם a matrix - mat = [[ 5]] המסקנה צריכה להיות - 5 השהה את הקריאה ויישם את ההחלטה שלך. הפתרון שלי יהיה הבא:

public static int countDiagonalSum(int[][] matrix) {
 int sum = 0;
 for (int i = 0, j = matrix.length - 1; i < matrix.length; i++, j--) {
   sum += matrix[i][i];
   if (j != i) {
     sum += matrix[i][j];
   }
 }
 return sum;
}

הכל קורה במעבר אחד במערך, שבמהלכו יש לנו שני אינדקסים לדוח: i - לדיווח על שורות המערך והעמודות של האלכסון הראשי, j - לדיווח על העמודות של האלכסון הנוסף. אם התא של האלכסון הראשי והתא הנוסף עולים בקנה אחד, אז מתעלמים מאחד הערכים בעת חישוב הסכום. בואו נבדוק באמצעות המטריצות מהתנאי:

int[][] arr1 = {
   {1, 2, 3},
   {4, 5, 6},
   {7, 8, 9}};
System.out.println(countDiagonalSum(arr1));

int[][] arr2 = {
   {1, 1, 1, 1},
   {1, 1, 1, 1},
   {1, 1, 1, 1},
   {1, 1, 1, 1}};
System.out.println(countDiagonalSum(arr2));

int[][] arr3 = {{5}};
System.out.println(countDiagonalSum(arr3));

פלט מסוף:

115. הזז אפסים (אתגר Leetcode)

תנאי: במערך שלמים, הזיזו את כל ה-0 עד הסוף, תוך שמירה על הסדר היחסי של אלמנטים שאינם אפס. 1. עם מערך: [0,1,0,3,12] הפלט צריך להיות: [1,3,12,0,0] 2. עם מערך: [0] הפלט צריך להיות: [0] השהה וכתוב את ההחלטה שלי... ההחלטה שלי:

public static void moveZeroes(int[] nums) {
 int counterWithoutNulls = 0;
 int counterWithNulls = 0;
 int length = nums.length;
 while (counterWithNulls < length) {
   if (nums[counterWithNulls] == 0) {// находим нулевые элементы и увеличиваем счётчик
     counterWithNulls++;
   } else { // сдвигаем элементы на количество найденных нулевых элементов слева
     nums[counterWithoutNulls++] = nums[counterWithNulls++];
   }
 }
 while (counterWithoutNulls < length) {
   nums[counterWithoutNulls++] = 0;// заполняем последние элементы массива нулями согласно счётчику нулей
 }
}

בְּדִיקָה:

int[] arr1 = {1, 2, 0, 0, 12, 9};
moveZeroes(arr1);
System.out.println(Arrays.toString(arr1));

int[] arr2 = {0};
moveZeroes(arr2);
System.out.println(Arrays.toString(arr2));

פלט מסוף:

116. נתון רשימה <String> שמות. הסר את האות הראשונה מכל שם וסובב את הרשימה הממוינת

1. הדבר הראשון שעולה על הדעת הוא השיטות של המחלקה Collections , המכילה שיטות עזר רבות לאוספים:

public static List<String> processTheList(List<String> nameList) {
 for (int i = 0; i < nameList.size(); i++) {
   nameList.set(i, nameList.get(i).substring(1));
 }
 Collections.sort(nameList);
 return nameList;
}

2. כמו כן, אם אנחנו משתמשים ב-Java גרסה 8 ומעלה, אנחנו פשוט צריכים להציג את הפתרון באמצעות זרמים:

public static List<String> processTheList(List<String> nameList) {
 return nameList.stream()
     .map(x -> x.substring(1))
     .sorted().collect(Collectors.toList());
}

ללא קשר לפתרון הנבחר, ההמחאה עשויה להיות כדלקמן:

List<String> nameList = new ArrayList();
nameList.add("John");
nameList.add("Bob");
nameList.add("Anna");
nameList.add("Dmitriy");
nameList.add("Peter");
nameList.add("David");
nameList.add("Igor");

System.out.println(processTheList(nameList));

פלט מסוף:

117. הפוך את המערך

פתרון 1 שוב, הדבר הראשון שעולה על הדעת הוא להשתמש בשיטות של מחלקת השירות העזר Collections . אבל מכיוון שיש לנו מערך, ראשית עלינו להמיר אותו לאוסף (רשימה):

public static Integer[] reverse(Integer[] arr) {
 List<Integer> list = Arrays.asList(arr);
 Collections.reverse(list);
 return list.toArray(arr);
}

פתרון 2 מכיוון שהשאלה הייתה על מערך, אני חושב שיש צורך להציג את הפתרון מבלי להשתמש בפונקציונליות מוכנה מחוץ לקופסה, וכך לומר, לפי הקלאסיקה:

public static Integer[] reverse(Integer[] arr) {
 for (int i = 0; i < arr.length / 2; i++) {
   int temp = arr[i];
   arr[i] = arr[arr.length - 1 - i];
   arr[arr.length - 1 - i] = temp;
 }
 return arr;
}

בְּדִיקָה:

Integer[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
System.out.println(Arrays.toString(reverse(arr)));

פלט מסוף:

118. בדוק אם מיתר הוא פלינדרום

פתרון 1 כדאי לזכור מיד את StringBuilder : הוא גמיש יותר ועשיר בשיטות שונות בהשוואה ל- String רגיל . אנו מתעניינים במיוחד בשיטה ההפוכה :

public static boolean isPalindrome(String string) {
 string = string.toLowerCase(); //приводит всю строку к нижнему регистру
 StringBuilder builder = new StringBuilder();
 builder.append(string);
 builder.reverse(); // перевочиваем строку методом Builder-а
 return (builder.toString()).equals(string);
}

פתרון: הגישה הבאה תהיה ללא שימוש ב"פרצות" מחוץ לקופסה. אנו משווים את התווים מהחלק האחורי של המחרוזת עם התווים המקבילים מלפנים:

public static boolean isPalindrome(String string) {
  string = string.toLowerCase();
 int length = string.length();
 int fromBeginning = 0;
 int fromEnd = length - 1;
 while (fromEnd > fromBeginning) {
   char forwardChar = string.charAt(fromBeginning++);
   char backwardChar = string.charAt(fromEnd--);
   if (forwardChar != backwardChar)
     return false;
 }
 return true;
}

ואנחנו בודקים את שתי הגישות:

boolean isPalindrome = isPalindrome("Tenet");
System.out.println(isPalindrome);

פלט מסוף:

119. כתבו אלגוריתם מיון פשוט (בועה, בחירה או מעבורת). איך אפשר לשפר?

בתור אלגוריתם פשוט ליישום, בחרתי במיון בחירה - מיון בחירה:

public static void selectionSorting(int[] arr) {
 for (int i = 0; i < arr.length - 1; i++) {
   int min = i;
   for (int j = i + 1; j < arr.length; j++) {
     if (arr[j] < arr[min]) {
       min = j; // выбираем минимальный элемент в текущем числовом отрезке
     }
   }
   int temp = arr[min]; // меняем местами минимальный элемент с элементом под индексом i
   arr[min] = arr[i]; // так How отрезок постоянно уменьшается
   arr[i] = temp; // и выпадающие из него числа будут минимальными в текущем отрезке
 } // и How итог - числа оставшиеся вне текущей итерации отсортированы от самого наименьшего к большему
}

הגרסה המשופרת תיראה כך:

public static void improvedSelectionSorting(int[] arr) {
 for (int i = 0, j = arr.length - 1; i < j; i++, j--) { // рассматриваемый отрезок с каждой итерацией
   // будет уменьшаться с ДВУХ сторон по одному элементу
   int min = arr[i];
   int max = arr[i];
   int minIndex = i;
   int maxIndex = i;
   for (int n = i; n <= j; n++) { // выбираем min и max на текущем отрезке
     if (arr[n] > max) {
       max = arr[n];
       maxIndex = n;
     } else if (arr[n] < min) {
       min = arr[n];
       minIndex = n;
     }
   }
   // меняем найденный минимальный элемент с позиции с индексом min на позицию с индексом i
   swap(arr, i, minIndex);

   if (arr[minIndex] == max) {// срабатывает, если элемент max оказался смещен предыдущей перестановкой -
     swap(arr, j, minIndex); // на старое место min, поэтому с позиции с индексом min смещаем его на позицию j
   } else {
     swap(arr, j, maxIndex); // простое обмен местами элементов с индексами max и j
   }
 }
}

static int[] swap(int[] arr, int i, int j) {
 int temp = arr[i];
 arr[i] = arr[j];
 arr[j] = temp;
 return arr;
}

ובכן, כעת עלינו לוודא אם המיון באמת השתפר. בואו נשווה ביצועים:

long firstDifference = 0;
long secondDifference = 0;
long primaryTime;
int countOfApplying = 10000;
for (int i = 0; i < countOfApplying; i++) {
 int[] arr1 = {234, 33, 123, 4, 5342, 76, 3, 65,
     3, 5, 35, 75, 255, 4, 46, 48, 4658, 44, 22,
     678, 324, 66, 151, 268, 433, 76, 372, 45, 13,
     9484, 499959, 567, 774, 473, 3, 32, 865, 67, 43,
     63, 332, 24, 1};
 primaryTime = System.nanoTime();
 selectionSorting(arr1);
 firstDifference += System.nanoTime() - primaryTime;

 int[] arr2 = {234, 33, 123, 4, 5342, 76, 3, 65,
     3, 5, 35, 75, 255, 4, 46, 48, 4658, 44, 22,
     678, 324, 66, 151, 268, 433, 76, 372, 45, 13,
     9484, 499959, 567, 774, 473, 3, 32, 865, 67, 43,
     63, 332, 24, 1};
 primaryTime = System.nanoTime();
 improvedSelectionSorting(arr2);
 secondDifference += System.nanoTime() - primaryTime;
}

System.out.println(((double) firstDifference / (double) secondDifference - 1) * 100 + "%");

שני המינים התחילו באותו מחזור, כי אם היו לולאות נפרדות, מיון בקוד למעלה יראה תוצאה גרועה יותר מאשר אם הוא היה ממוקם במקום השני. זה נובע מהעובדה שהתוכנית "מתחממת" ואז עובדת קצת יותר מהר. אבל אני יוצא קצת מהנושא. לאחר חמש ריצות של בדיקה זו בקונסולה, ראיתי עלייה בביצועים ב -36.41006735635892% 51.46131097160771% 41.88918834013988% 48.09198070574371460% עבורי, 49% זה עבורי תוצאה טובה למדי.

120. כתוב אלגוריתם (רצף פעולות) לחיבור ליטרלי מסוג int עם ליטרלי מסוג בת. הסבר מה קורה לזיכרון

1. ערך בתים מומר ל-int. לא יוקצה עבורו בייט 1 של זיכרון, אלא כמו כל ערכי int - 4, אם הערך הזה עדיין לא נמצא בערימת int. אם יש, קישור אליו פשוט יתקבל.

2. שני ערכי int יתווספו והשלישי יתקבל. יוקצה עבורו קטע זיכרון חדש - 4 בתים (או תתקבל הפניה מחסנית int לערך הקיים).

   במקרה זה, הזיכרון של שני אינטס עדיין יהיה תפוס, והערכים שלהם יאוחסנו בערימת ה-ints, בהתאמה.

למעשה, כאן מסתיימות השאלות ברמת הג'וניור ברשימה שלנו. החל מהמאמר הבא, נבין בעיות ברמה הבינונית. ברצוני לציין ששאלות ברמה בינונית נשאלות גם למפתחים ברמת התחלה - ג'וניור. אז הישארו מעודכנים. ובכן, זה הכל להיום: נתראה!