Java
რა კლასებს შეგიძლიათ დაასახელოთ კონტეინერის კონფიგურაციისთვის?
კლასში ორი ველი და მათი invariants (ერთი მკაცრად ნაკლებია მეორისგან), თითოეული დაცული AtomicInteger-ით, ეს საკმარისია ნაკადი უსაფრთხოებისთვის?
როგორ უზრუნველვყოთ მრავალი სერვისის განაწილებული ტრანზაქცია?
გაქვს გამოცდილება რიგების გამოყენებაში თქვენს პროექტებში?
შეგიძლიათ კოდში სტატიკური ბლოკის გამოყენების მაგალითი მოიყვანოთ?
არის საჭირო განყოფილება ცხრილებს ნაწილებად (sharding) გასაუმჯობესებლად შეკითხვების სიჩქარის?
რა სარგებელი და ნაკლია Protocol Buffer-ის გამოყენებაში მონაცემების სერილიზაციისთვის?
Spring-ში @Transactional-ის გამოყენების მახასიათებლები. ტრანზაქციების იზოლაციის დონეები.
გვითხარით, როგორ იყო ორგანიზებული თქვენი წინა სამუშაო ადგილზე განვითარების პროცესი — ბიზნეს საჭიროებიდან გამოშვებამდე.
როგორ არის განხორციელებული ტრანზაქციების მხარდაჭერა @Transactional ანოტაციით Spring Framework-ში?
თქვენ მუშაობდით თქვენს პროექტებში Spring Data და Hibernate ინტეგრაციასთან?
როდის და როგორ იძახიან სტატიკური ფუნქციები: ობიექტზე თუ კლასზე?
გაქვს გამოცდილება Data API-ში parallel მეთოდის გამოყენებაში მონაცემების პარალელური დამუშავებისთვის?
როგორ ირკვევა ობიექტის Bean-ის ხილვადობის სფერო სტანდარტული პირობებში?
შეგიძლიათ ახსნათ @SpringBootTest ანოტაციის მოქმედების მექანიზმი Spring Boot-ის ტესტებში?
რა მიდგომებია, რათა გაუმკლავდე არასტაბილურ ინტეგრაციას, რომელიც შეიძლება პასუხს არ გასცეს წუთიდან დღემდე?
რა განსხვავებაა ძირითადი მონაცემთა ტიპების გამოყენებასა და მათი ობიექტური შრიფტების გამოყენებას შორის შესრულების თვალსაზრისით?
ქვემოთ მოცემული კოდის ფრაგმენტების შესრულების სიჩქარის შედარება, რომლებიც ასლირებენ ელემენტებს Integer მასივიდან int მასივში და პირიქით, მათ შორის შემთხვევა, როდესაც ახალი Integer ობიექტები იქმნება int მნიშვნელობებიდან: ```java int SIZE = 1000000; int[] x = new int[SIZE]; Integer[] y = new Integer[SIZE]; for (;;) { for (int i = 0; i < SIZE; ++i) { x[i] = y[i]; } } ``` ```java int SIZE = 1000000; int[] x = new int[SIZE]; Integer[] y = new Integer[SIZE]; for (;;) { for (int i = 0; i < SIZE; ++i) { y[i] = x[i]; } } ``` ```java int SIZE = 1000000; int[] x = new int[SIZE]; Integer[] y = new Integer[SIZE]; for (;;) { for (int i = 0; i < SIZE; ++i) { y[i] = new Integer(x[i]); } } ``` გაანალიზეთ და ახსენით ამ მიდგომების შესრულების სიჩქარის და ქცევის განსხვავებები.
თქვენ გამოიყენეთ თქვენი პროექტების ფარგლებში ExecutorService კომპონენტი ნაკადების მართვისთვის?
როგორ ხორციელდება გამონაკლისების მართვა Java-ს Stream ნაკადების შესრულებისას?